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