1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define LOG_TAG "JS_Query"
16 #include "js_query.h"
17 #include "js_util.h"
18 #include "log_print.h"
19 #include "napi_queue.h"
20 #include "uv_queue.h"
21
22 using namespace OHOS::DistributedKv;
23
24 namespace OHOS::DistributedKVStore {
GetDataQuery()25 DataQuery& JsQuery::GetDataQuery()
26 {
27 return query_;
28 }
29
Constructor(napi_env env)30 napi_value JsQuery::Constructor(napi_env env)
31 {
32 const napi_property_descriptor properties[] = {
33 DECLARE_NAPI_FUNCTION("reset", JsQuery::Reset),
34 DECLARE_NAPI_FUNCTION("equalTo", JsQuery::EqualTo),
35 DECLARE_NAPI_FUNCTION("notEqualTo", JsQuery::NotEqualTo),
36 DECLARE_NAPI_FUNCTION("greaterThan", JsQuery::GreaterThan),
37 DECLARE_NAPI_FUNCTION("lessThan", JsQuery::LessThan),
38 DECLARE_NAPI_FUNCTION("greaterThanOrEqualTo", JsQuery::GreaterThanOrEqualTo),
39 DECLARE_NAPI_FUNCTION("lessThanOrEqualTo", JsQuery::LessThanOrEqualTo),
40 DECLARE_NAPI_FUNCTION("isNull", JsQuery::IsNull),
41 DECLARE_NAPI_FUNCTION("inNumber", JsQuery::InNumber),
42 DECLARE_NAPI_FUNCTION("inString", JsQuery::InString),
43 DECLARE_NAPI_FUNCTION("notInNumber", JsQuery::NotInNumber),
44 DECLARE_NAPI_FUNCTION("notInString", JsQuery::NotInString),
45 DECLARE_NAPI_FUNCTION("like", JsQuery::Like),
46 DECLARE_NAPI_FUNCTION("unlike", JsQuery::Unlike),
47 DECLARE_NAPI_FUNCTION("and", JsQuery::And),
48 DECLARE_NAPI_FUNCTION("or", JsQuery::Or),
49 DECLARE_NAPI_FUNCTION("orderByAsc", JsQuery::OrderByAsc),
50 DECLARE_NAPI_FUNCTION("orderByDesc", JsQuery::OrderByDesc),
51 DECLARE_NAPI_FUNCTION("limit", JsQuery::Limit),
52 DECLARE_NAPI_FUNCTION("isNotNull", JsQuery::IsNotNull),
53 DECLARE_NAPI_FUNCTION("beginGroup", JsQuery::BeginGroup),
54 DECLARE_NAPI_FUNCTION("endGroup", JsQuery::EndGroup),
55 DECLARE_NAPI_FUNCTION("prefixKey", JsQuery::PrefixKey),
56 DECLARE_NAPI_FUNCTION("setSuggestIndex", JsQuery::SetSuggestIndex),
57 DECLARE_NAPI_FUNCTION("deviceId", JsQuery::DeviceId),
58 DECLARE_NAPI_FUNCTION("getSqlLike", JsQuery::GetSqlLike)
59 };
60 size_t count = sizeof(properties) / sizeof(properties[0]);
61 return JSUtil::DefineClass(env, "Query", properties, count, JsQuery::New);
62 }
63
64 /*
65 * [JS API Prototype]
66 * var query = new ddm.JsQuery();
67 */
New(napi_env env,napi_callback_info info)68 napi_value JsQuery::New(napi_env env, napi_callback_info info)
69 {
70 auto ctxt = std::make_shared<ContextBase>();
71 ctxt->GetCbInfoSync(env, info);
72 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The parameter is incorrect.");
73
74 JsQuery* query = new (std::nothrow) JsQuery();
75 ASSERT_ERR(env, query != nullptr, Status::INVALID_ARGUMENT, "no memory for query.");
76
77 auto finalize = [](napi_env env, void* data, void* hint) {
78 ZLOGD("query finalize.");
79 auto* query = reinterpret_cast<JsQuery*>(data);
80 ASSERT_VOID(query != nullptr, "finalize null!");
81 delete query;
82 };
83 ASSERT_CALL(env, napi_wrap(env, ctxt->self, query, finalize, nullptr, nullptr), query);
84 return ctxt->self;
85 }
86
Reset(napi_env env,napi_callback_info info)87 napi_value JsQuery::Reset(napi_env env, napi_callback_info info)
88 {
89 auto ctxt = std::make_shared<ContextBase>();
90 ctxt->GetCbInfoSync(env, info);
91 NAPI_ASSERT(env, ctxt->status == napi_ok, "invalid arguments!");
92
93 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
94 query.Reset();
95 return ctxt->self;
96 }
97
98 struct ValueContext : public ContextBase {
99 std::string field;
100 JSUtil::QueryVariant vv;
101
GetValueSyncOHOS::DistributedKVStore::ValueContext102 void GetValueSync(napi_env env, napi_callback_info info)
103 {
104 auto input = [this, env](size_t argc, napi_value* argv) {
105 // required 2 arguments :: <field> <value>
106 ASSERT_BUSINESS_ERR(this, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
107 status = JSUtil::GetValue(env, argv[0], field);
108 ASSERT_BUSINESS_ERR(this, status == napi_ok, Status::INVALID_ARGUMENT,
109 "The parameters field is incorrect.");
110 status = JSUtil::GetValue(env, argv[1], vv);
111 ASSERT_BUSINESS_ERR(this, status == napi_ok, Status::INVALID_ARGUMENT,
112 "The parameters value is incorrect.");
113 };
114 GetCbInfoSync(env, info, input);
115 }
116 };
117
118 /* [js] equalTo(field:string, value:number|string|boolean):JsQuery */
EqualTo(napi_env env,napi_callback_info info)119 napi_value JsQuery::EqualTo(napi_env env, napi_callback_info info)
120 {
121 ZLOGD("Query::EqualTo()");
122 auto ctxt = std::make_shared<ValueContext>();
123 ctxt->GetValueSync(env, info);
124 if (ctxt->isThrowError) {
125 ZLOGE("EqualTo exit");
126 return nullptr;
127 }
128 ASSERT_NULL(!ctxt->isThrowError, "EqualTo exit");
129 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function EqualTo parameter is incorrect.");
130
131 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
132 auto strValue = std::get_if<std::string>(&ctxt->vv);
133 if (strValue != nullptr) {
134 query.EqualTo(ctxt->field, *strValue);
135 } else {
136 auto boolValue = std::get_if<bool>(&ctxt->vv);
137 if (boolValue != nullptr) {
138 query.EqualTo(ctxt->field, *boolValue);
139 } else {
140 auto dblValue = std::get_if<double>(&ctxt->vv);
141 if (dblValue != nullptr) {
142 query.EqualTo(ctxt->field, *dblValue);
143 }
144 }
145 }
146 return ctxt->self;
147 }
148
NotEqualTo(napi_env env,napi_callback_info info)149 napi_value JsQuery::NotEqualTo(napi_env env, napi_callback_info info)
150 {
151 ZLOGD("Query::NotEqualTo()");
152 auto ctxt = std::make_shared<ValueContext>();
153 ctxt->GetValueSync(env, info);
154 ASSERT_NULL(!ctxt->isThrowError, "NotEqualTo exit");
155 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
156 "The function NotEqualTo parameter is incorrect.");
157
158 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
159 auto strValue = std::get_if<std::string>(&ctxt->vv);
160 if (strValue != nullptr) {
161 query.NotEqualTo(ctxt->field, *strValue);
162 } else {
163 auto boolValue = std::get_if<bool>(&ctxt->vv);
164 if (boolValue != nullptr) {
165 query.NotEqualTo(ctxt->field, *boolValue);
166 } else {
167 auto dblValue = std::get_if<double>(&ctxt->vv);
168 if (dblValue != nullptr) {
169 query.NotEqualTo(ctxt->field, *dblValue);
170 }
171 }
172 }
173 return ctxt->self;
174 }
175
GreaterThan(napi_env env,napi_callback_info info)176 napi_value JsQuery::GreaterThan(napi_env env, napi_callback_info info)
177 {
178 ZLOGD("Query::GreaterThan()");
179 auto ctxt = std::make_shared<ValueContext>();
180 ctxt->GetValueSync(env, info);
181 ASSERT_NULL(!ctxt->isThrowError, "GreaterThan exit");
182 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
183 "The function GreaterThan parameter is incorrect.");
184
185 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
186 auto strValue = std::get_if<std::string>(&ctxt->vv);
187 if (strValue != nullptr) {
188 query.GreaterThan(ctxt->field, *strValue);
189 } else {
190 auto boolValue = std::get_if<bool>(&ctxt->vv);
191 if (boolValue != nullptr) {
192 query.GreaterThan(ctxt->field, *boolValue);
193 } else {
194 auto dblValue = std::get_if<double>(&ctxt->vv);
195 if (dblValue != nullptr) {
196 query.GreaterThan(ctxt->field, *dblValue);
197 }
198 }
199 }
200 return ctxt->self;
201 }
202
LessThan(napi_env env,napi_callback_info info)203 napi_value JsQuery::LessThan(napi_env env, napi_callback_info info)
204 {
205 ZLOGD("Query::LessThan()");
206 auto ctxt = std::make_shared<ValueContext>();
207 ctxt->GetValueSync(env, info);
208 ASSERT_NULL(!ctxt->isThrowError, "LessThan exit");
209 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function LessThan parameter is incorrect.");
210
211 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
212 auto strValue = std::get_if<std::string>(&ctxt->vv);
213 if (strValue != nullptr) {
214 query.LessThan(ctxt->field, *strValue);
215 } else {
216 auto boolValue = std::get_if<bool>(&ctxt->vv);
217 if (boolValue != nullptr) {
218 query.LessThan(ctxt->field, *boolValue);
219 } else {
220 auto dblValue = std::get_if<double>(&ctxt->vv);
221 if (dblValue != nullptr) {
222 query.LessThan(ctxt->field, *dblValue);
223 }
224 }
225 }
226 return ctxt->self;
227 }
228
GreaterThanOrEqualTo(napi_env env,napi_callback_info info)229 napi_value JsQuery::GreaterThanOrEqualTo(napi_env env, napi_callback_info info)
230 {
231 ZLOGD("Query::GreaterThanOrEqualTo()");
232 auto ctxt = std::make_shared<ValueContext>();
233 ctxt->GetValueSync(env, info);
234 ASSERT_NULL(!ctxt->isThrowError, "GreaterThanOrEqualTo exit");
235 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
236 "The function GreaterThanOrEqualTo parameter is incorrect.");
237
238 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
239 auto strValue = std::get_if<std::string>(&ctxt->vv);
240 if (strValue != nullptr) {
241 query.GreaterThanOrEqualTo(ctxt->field, *strValue);
242 } else {
243 auto boolValue = std::get_if<bool>(&ctxt->vv);
244 if (boolValue != nullptr) {
245 query.GreaterThanOrEqualTo(ctxt->field, *boolValue);
246 } else {
247 auto dblValue = std::get_if<double>(&ctxt->vv);
248 if (dblValue != nullptr) {
249 query.GreaterThanOrEqualTo(ctxt->field, *dblValue);
250 }
251 }
252 }
253 return ctxt->self;
254 }
255
LessThanOrEqualTo(napi_env env,napi_callback_info info)256 napi_value JsQuery::LessThanOrEqualTo(napi_env env, napi_callback_info info)
257 {
258 ZLOGD("Query::LessThanOrEqualTo()");
259 auto ctxt = std::make_shared<ValueContext>();
260 ctxt->GetValueSync(env, info);
261 ASSERT_NULL(!ctxt->isThrowError, "LessThanOrEqualTo exit");
262 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
263 "The function LessThanOrEqualTo parameter is incorrect.");
264
265 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
266 auto strValue = std::get_if<std::string>(&ctxt->vv);
267 if (strValue != nullptr) {
268 query.LessThanOrEqualTo(ctxt->field, *strValue);
269 } else {
270 auto boolValue = std::get_if<bool>(&ctxt->vv);
271 if (boolValue != nullptr) {
272 query.LessThanOrEqualTo(ctxt->field, *boolValue);
273 } else {
274 auto dblValue = std::get_if<double>(&ctxt->vv);
275 if (dblValue != nullptr) {
276 query.LessThanOrEqualTo(ctxt->field, *dblValue);
277 }
278 }
279 }
280 return ctxt->self;
281 }
282
IsNull(napi_env env,napi_callback_info info)283 napi_value JsQuery::IsNull(napi_env env, napi_callback_info info)
284 {
285 std::string field;
286 auto ctxt = std::make_shared<ContextBase>();
287 auto input = [env, ctxt, &field](size_t argc, napi_value* argv) {
288 // required 1 arguments :: <field>
289 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
290 ctxt->status = JSUtil::GetValue(env, argv[0], field);
291 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
292 "The parameters field is incorrect.");
293 };
294 ctxt->GetCbInfoSync(env, info, input);
295 ASSERT_NULL(!ctxt->isThrowError, "IsNull exit");
296 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function IsNull parameter is incorrect.");
297
298 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
299 query.IsNull(field);
300 return ctxt->self;
301 }
302
303 /*
304 * InNumber / NotInNumber
305 * [NOTES] Recommended to use the napi_typedarray_type
306 */
307 enum class NumberType : uint8_t {
308 NUMBER_INT,
309 NUMBER_LONG,
310 NUMBER_DOUBLE,
311 NUMBER_INVALID = 255
312 };
313 struct NumbersContext : public ContextBase {
314 std::string field;
315 std::vector<int> intList;
316 std::vector<int64_t> longList;
317 std::vector<double> doubleList;
318 NumberType innerType = NumberType::NUMBER_INVALID;
319
GetNumberSyncOHOS::DistributedKVStore::NumbersContext320 void GetNumberSync(napi_env env, napi_callback_info info)
321 {
322 auto input = [this, env](size_t argc, napi_value* argv) {
323 // required 2 arguments :: <field> <value-list>
324 ASSERT_BUSINESS_ERR(this, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
325 status = JSUtil::GetValue(env, argv[0], field);
326 ASSERT_BUSINESS_ERR(this, status == napi_ok, Status::INVALID_ARGUMENT,
327 "The parameters field is incorrect.");
328 bool isTypedArray = false;
329 status = napi_is_typedarray(env, argv[1], &isTypedArray);
330 ZLOGD("arg[1] %{public}s a TypedArray", isTypedArray ? "is" : "is not");
331 if (isTypedArray && (status == napi_ok)) {
332 napi_typedarray_type type = napi_biguint64_array;
333 size_t length = 0;
334 napi_value buffer = nullptr;
335 size_t offset = 0;
336 void* data = nullptr;
337 status = napi_get_typedarray_info(env, argv[1], &type, &length, &data, &buffer, &offset);
338 ASSERT_BUSINESS_ERR(this, status == napi_ok, Status::INVALID_ARGUMENT,
339 "The parameters number array is incorrect.");
340 if (type < napi_uint32_array) {
341 status = JSUtil::GetValue(env, argv[1], intList);
342 innerType = NumberType::NUMBER_INT;
343 } else if (type == napi_bigint64_array || type == napi_uint32_array) {
344 status = JSUtil::GetValue(env, argv[1], longList);
345 innerType = NumberType::NUMBER_LONG;
346 } else {
347 status = JSUtil::GetValue(env, argv[1], doubleList);
348 innerType = NumberType::NUMBER_DOUBLE;
349 }
350 } else {
351 bool isArray = false;
352 status = napi_is_array(env, argv[1], &isArray);
353 ASSERT_BUSINESS_ERR(this, isArray, Status::INVALID_ARGUMENT,
354 "The type of parameters number array is incorrect.");
355 ZLOGD("arg[1] %{public}s a Array, treat as array of double.", isTypedArray ? "is" : "is not");
356 status = JSUtil::GetValue(env, argv[1], doubleList);
357 ASSERT_BUSINESS_ERR(this, status == napi_ok, Status::INVALID_ARGUMENT,
358 "The parameters number array is incorrect.");
359 innerType = NumberType::NUMBER_DOUBLE;
360 }
361 };
362 GetCbInfoSync(env, info, input);
363 }
364 };
365
InNumber(napi_env env,napi_callback_info info)366 napi_value JsQuery::InNumber(napi_env env, napi_callback_info info)
367 {
368 ZLOGD("Query::InNumber()");
369 auto ctxt = std::make_shared<NumbersContext>();
370 ctxt->GetNumberSync(env, info);
371 ASSERT_NULL(!ctxt->isThrowError, "InNumber exit");
372 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function InNumber parameter is incorrect.");
373
374 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
375 if (ctxt->innerType == NumberType::NUMBER_INT) {
376 query.In(ctxt->field, ctxt->intList);
377 } else if (ctxt->innerType == NumberType::NUMBER_LONG) {
378 query.In(ctxt->field, ctxt->longList);
379 } else if (ctxt->innerType == NumberType::NUMBER_DOUBLE) {
380 query.In(ctxt->field, ctxt->doubleList);
381 }
382 return ctxt->self;
383 }
384
InString(napi_env env,napi_callback_info info)385 napi_value JsQuery::InString(napi_env env, napi_callback_info info)
386 {
387 ZLOGD("Query::InString()");
388 struct StringsContext : public ContextBase {
389 std::string field;
390 std::vector<std::string> valueList;
391 };
392 auto ctxt = std::make_shared<StringsContext>();
393 auto input = [env, ctxt](size_t argc, napi_value* argv) {
394 // required 2 arguments :: <field> <valueList>
395 ASSERT_BUSINESS_ERR(ctxt, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
396 ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->field);
397 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
398 "The type of field must be string.");
399 ctxt->status = JSUtil::GetValue(env, argv[1], ctxt->valueList);
400 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
401 "The type of valueList must be array.");
402 };
403 ctxt->GetCbInfoSync(env, info, input);
404 ASSERT_NULL(!ctxt->isThrowError, "InString exit");
405 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function InString parameter is incorrect.");
406
407 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
408 query.In(ctxt->field, ctxt->valueList);
409 return ctxt->self;
410 }
411
NotInNumber(napi_env env,napi_callback_info info)412 napi_value JsQuery::NotInNumber(napi_env env, napi_callback_info info)
413 {
414 ZLOGD("Query::NotInNumber()");
415 auto ctxt = std::make_shared<NumbersContext>();
416 ctxt->GetNumberSync(env, info);
417 ASSERT_NULL(!ctxt->isThrowError, "NotInNumber exit");
418 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
419 "The function InString NotInNumber is incorrect.");
420
421 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
422 if (ctxt->innerType == NumberType::NUMBER_INT) {
423 query.NotIn(ctxt->field, ctxt->intList);
424 } else if (ctxt->innerType == NumberType::NUMBER_LONG) {
425 query.NotIn(ctxt->field, ctxt->longList);
426 } else if (ctxt->innerType == NumberType::NUMBER_DOUBLE) {
427 query.NotIn(ctxt->field, ctxt->doubleList);
428 }
429 return ctxt->self;
430 }
431
NotInString(napi_env env,napi_callback_info info)432 napi_value JsQuery::NotInString(napi_env env, napi_callback_info info)
433 {
434 ZLOGD("Query::NotInString()");
435 struct StringsContext : public ContextBase {
436 std::string field;
437 std::vector<std::string> valueList;
438 };
439 auto ctxt = std::make_shared<StringsContext>();
440 auto input = [env, ctxt](size_t argc, napi_value* argv) {
441 // required 2 arguments :: <field> <valueList>
442 ASSERT_BUSINESS_ERR(ctxt, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
443 ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->field);
444 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
445 "The type of field must be string.");
446 ctxt->status = JSUtil::GetValue(env, argv[1], ctxt->valueList);
447 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
448 "The type of valueList must be array.");
449 };
450 ctxt->GetCbInfoSync(env, info, input);
451 ASSERT_NULL(!ctxt->isThrowError, "NotInString exit");
452 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function NotInString is incorrect.");
453
454 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
455 query.NotIn(ctxt->field, ctxt->valueList);
456 return ctxt->self;
457 }
458
Like(napi_env env,napi_callback_info info)459 napi_value JsQuery::Like(napi_env env, napi_callback_info info)
460 {
461 ZLOGD("Query::Like()");
462 struct LikeContext : public ContextBase {
463 std::string field;
464 std::string value;
465 };
466 auto ctxt = std::make_shared<LikeContext>();
467 auto input = [env, ctxt](size_t argc, napi_value* argv) {
468 // required 2 arguments :: <field> <value>
469 ASSERT_BUSINESS_ERR(ctxt, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
470 ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->field);
471 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
472 "The type of field must be string.");
473 ctxt->status = JSUtil::GetValue(env, argv[1], ctxt->value);
474 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
475 "The type of value must be string.");
476 };
477 ctxt->GetCbInfoSync(env, info, input);
478 ASSERT_NULL(!ctxt->isThrowError, "Like exit");
479 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function Like is incorrect.");
480
481 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
482 query.Like(ctxt->field, ctxt->value);
483 return ctxt->self;
484 }
485
Unlike(napi_env env,napi_callback_info info)486 napi_value JsQuery::Unlike(napi_env env, napi_callback_info info)
487 {
488 ZLOGD("Query::Unlike()");
489 struct UnlikeContext : public ContextBase {
490 std::string field;
491 std::string value;
492 };
493 auto ctxt = std::make_shared<UnlikeContext>();
494 auto input = [env, ctxt](size_t argc, napi_value* argv) {
495 // required 2 arguments :: <field> <value>
496 ASSERT_BUSINESS_ERR(ctxt, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
497 ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->field);
498 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
499 "The type of field must be string.");
500 ctxt->status = JSUtil::GetValue(env, argv[1], ctxt->value);
501 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
502 "The type of value must be string.");
503 };
504 ctxt->GetCbInfoSync(env, info, input);
505 ASSERT_NULL(!ctxt->isThrowError, "Unlike exit");
506 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function Unlike is incorrect.");
507
508 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
509 query.Unlike(ctxt->field, ctxt->value);
510 return ctxt->self;
511 }
512
And(napi_env env,napi_callback_info info)513 napi_value JsQuery::And(napi_env env, napi_callback_info info)
514 {
515 ZLOGD("Query::And()");
516 auto ctxt = std::make_shared<ContextBase>();
517 ctxt->GetCbInfoSync(env, info);
518 NAPI_ASSERT(env, ctxt->status == napi_ok, "invalid arguments!");
519
520 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
521 query.And();
522 return ctxt->self;
523 }
524
Or(napi_env env,napi_callback_info info)525 napi_value JsQuery::Or(napi_env env, napi_callback_info info)
526 {
527 ZLOGD("Query::Or()");
528 auto ctxt = std::make_shared<ContextBase>();
529 ctxt->GetCbInfoSync(env, info);
530 NAPI_ASSERT(env, ctxt->status == napi_ok, "invalid arguments!");
531
532 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
533 query.Or();
534 return ctxt->self;
535 }
536
OrderByAsc(napi_env env,napi_callback_info info)537 napi_value JsQuery::OrderByAsc(napi_env env, napi_callback_info info)
538 {
539 ZLOGD("Query::OrderByAsc()");
540 std::string field;
541 auto ctxt = std::make_shared<ContextBase>();
542 auto input = [env, ctxt, &field](size_t argc, napi_value* argv) {
543 // required 1 arguments :: <field>
544 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
545 ctxt->status = JSUtil::GetValue(env, argv[0], field);
546 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
547 "The type of field must be string.");
548 };
549 ctxt->GetCbInfoSync(env, info, input);
550 ASSERT_NULL(!ctxt->isThrowError, "OrderByAsc exit");
551 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function OrderByAsc is incorrect.");
552
553 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
554 query.OrderByAsc(field);
555 return ctxt->self;
556 }
557
OrderByDesc(napi_env env,napi_callback_info info)558 napi_value JsQuery::OrderByDesc(napi_env env, napi_callback_info info)
559 {
560 ZLOGD("Query::OrderByDesc()");
561 std::string field;
562 auto ctxt = std::make_shared<ContextBase>();
563 auto input = [env, ctxt, &field](size_t argc, napi_value* argv) {
564 // required 1 arguments :: <field>
565 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
566 ctxt->status = JSUtil::GetValue(env, argv[0], field);
567 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
568 "The type of field must be string.");
569 };
570 ctxt->GetCbInfoSync(env, info, input);
571 ASSERT_NULL(!ctxt->isThrowError, "OrderByDesc exit");
572 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function OrderByDesc is incorrect.");
573
574 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
575 query.OrderByDesc(field);
576 return ctxt->self;
577 }
578
Limit(napi_env env,napi_callback_info info)579 napi_value JsQuery::Limit(napi_env env, napi_callback_info info)
580 {
581 struct LimitContext : public ContextBase {
582 int number;
583 int offset;
584 };
585 auto ctxt = std::make_shared<LimitContext>();
586 auto input = [env, ctxt](size_t argc, napi_value* argv) {
587 // required 2 arguments :: <number> <offset>
588 ASSERT_BUSINESS_ERR(ctxt, argc >= 2, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
589 ctxt->status = napi_get_value_int32(env, argv[0], &ctxt->number);
590 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The type of number must be int.");
591 ctxt->status = napi_get_value_int32(env, argv[1], &ctxt->offset);
592 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The type of offset must be int.");
593 };
594 ctxt->GetCbInfoSync(env, info, input);
595 ASSERT_NULL(!ctxt->isThrowError, "Limit exit");
596 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function Limit is incorrect.");
597
598 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
599 query.Limit(ctxt->number, ctxt->offset);
600 return ctxt->self;
601 }
602
IsNotNull(napi_env env,napi_callback_info info)603 napi_value JsQuery::IsNotNull(napi_env env, napi_callback_info info)
604 {
605 ZLOGD("Query::IsNotNull()");
606 std::string field;
607 auto ctxt = std::make_shared<ContextBase>();
608 auto input = [env, ctxt, &field](size_t argc, napi_value* argv) {
609 // required 1 arguments :: <field>
610 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
611 ctxt->status = JSUtil::GetValue(env, argv[0], field);
612 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
613 "The type of field must be string.");
614 };
615 ctxt->GetCbInfoSync(env, info, input);
616 ASSERT_NULL(!ctxt->isThrowError, "IsNotNull exit");
617 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function IsNotNull is incorrect.");
618
619 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
620 query.IsNotNull(field);
621 return ctxt->self;
622 }
623
BeginGroup(napi_env env,napi_callback_info info)624 napi_value JsQuery::BeginGroup(napi_env env, napi_callback_info info)
625 {
626 ZLOGD("Query::BeginGroup()");
627 auto ctxt = std::make_shared<ContextBase>();
628 ctxt->GetCbInfoSync(env, info);
629 NAPI_ASSERT(env, ctxt->status == napi_ok, "invalid arguments!");
630
631 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
632 query.BeginGroup();
633 return ctxt->self;
634 }
635
EndGroup(napi_env env,napi_callback_info info)636 napi_value JsQuery::EndGroup(napi_env env, napi_callback_info info)
637 {
638 ZLOGD("Query::EndGroup()");
639 auto ctxt = std::make_shared<ContextBase>();
640 ctxt->GetCbInfoSync(env, info);
641 NAPI_ASSERT(env, ctxt->status == napi_ok, "invalid arguments!");
642
643 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
644 query.EndGroup();
645 return ctxt->self;
646 }
647
PrefixKey(napi_env env,napi_callback_info info)648 napi_value JsQuery::PrefixKey(napi_env env, napi_callback_info info)
649 {
650 std::string prefix;
651 auto ctxt = std::make_shared<ContextBase>();
652 auto input = [env, ctxt, &prefix](size_t argc, napi_value* argv) {
653 // required 1 arguments :: <prefix>
654 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
655 ctxt->status = JSUtil::GetValue(env, argv[0], prefix);
656 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
657 "The type of prefix must be string.");
658 };
659 ctxt->GetCbInfoSync(env, info, input);
660 ASSERT_NULL(!ctxt->isThrowError, "PrefixKey exit");
661 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function PrefixKey is incorrect.");
662
663 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
664 query.KeyPrefix(prefix);
665 return ctxt->self;
666 }
667
SetSuggestIndex(napi_env env,napi_callback_info info)668 napi_value JsQuery::SetSuggestIndex(napi_env env, napi_callback_info info)
669 {
670 std::string suggestIndex;
671 auto ctxt = std::make_shared<ContextBase>();
672 auto input = [env, ctxt, &suggestIndex](size_t argc, napi_value* argv) {
673 // required 1 arguments :: <suggestIndex>
674 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
675 ctxt->status = JSUtil::GetValue(env, argv[0], suggestIndex);
676 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
677 "The type of suggestIndex must be string.");
678 };
679 ctxt->GetCbInfoSync(env, info, input);
680 ASSERT_NULL(!ctxt->isThrowError, "SetSuggestIndex exit");
681 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function SetSuggestIndex is incorrect.");
682
683 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
684 query.SetSuggestIndex(suggestIndex);
685 return ctxt->self;
686 }
687
DeviceId(napi_env env,napi_callback_info info)688 napi_value JsQuery::DeviceId(napi_env env, napi_callback_info info)
689 {
690 std::string deviceId;
691 auto ctxt = std::make_shared<ContextBase>();
692 auto input = [env, ctxt, &deviceId](size_t argc, napi_value* argv) {
693 // required 1 arguments :: <deviceId>
694 ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect.");
695 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT,
696 "The type of deviceId must be string.");
697 ctxt->status = JSUtil::GetValue(env, argv[0], deviceId);
698 };
699 ctxt->GetCbInfoSync(env, info, input);
700 ASSERT_NULL(!ctxt->isThrowError, "DeviceId exit");
701 ASSERT_ERR(env, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The function DeviceId is incorrect.");
702
703 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
704 query.DeviceId(deviceId);
705 return ctxt->self;
706 }
707
708 // getSqlLike():string
GetSqlLike(napi_env env,napi_callback_info info)709 napi_value JsQuery::GetSqlLike(napi_env env, napi_callback_info info)
710 {
711 auto ctxt = std::make_shared<ContextBase>();
712 ctxt->GetCbInfoSync(env, info);
713 NAPI_ASSERT(env, ctxt->status == napi_ok, "invalid arguments!");
714
715 auto& query = reinterpret_cast<JsQuery*>(ctxt->native)->query_;
716 JSUtil::SetValue(env, query.ToString(), ctxt->output);
717 return ctxt->output;
718 }
719 } // namespace OHOS::DistributedKVStore
720