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 
16 #include "datashare_predicates_proxy.h"
17 
18 #include <cinttypes>
19 
20 #include "datashare_log.h"
21 #include "datashare_js_utils.h"
22 #include "datashare_predicates.h"
23 
24 namespace OHOS {
25 namespace DataShare {
26 static napi_ref __thread constructor_ = nullptr;
27 
GetConstructor(napi_env env)28 napi_value DataSharePredicatesProxy::GetConstructor(napi_env env)
29 {
30     napi_value cons;
31     if (constructor_ != nullptr) {
32         NAPI_CALL(env, napi_get_reference_value(env, constructor_, &cons));
33         return cons;
34     }
35     return CreateConstructor(env);
36 }
37 
CreateConstructor(napi_env env)38 napi_value DataSharePredicatesProxy::CreateConstructor(napi_env env)
39 {
40     napi_value cons;
41     napi_property_descriptor descriptors[] = {
42         DECLARE_NAPI_FUNCTION("equalTo", EqualTo),
43         DECLARE_NAPI_FUNCTION("notEqualTo", NotEqualTo),
44         DECLARE_NAPI_FUNCTION("beginWrap", BeginWrap),
45         DECLARE_NAPI_FUNCTION("endWrap", EndWrap),
46         DECLARE_NAPI_FUNCTION("or", Or),
47         DECLARE_NAPI_FUNCTION("and", And),
48         DECLARE_NAPI_FUNCTION("contains", Contains),
49         DECLARE_NAPI_FUNCTION("beginsWith", BeginsWith),
50         DECLARE_NAPI_FUNCTION("endsWith", EndsWith),
51         DECLARE_NAPI_FUNCTION("isNull", IsNull),
52         DECLARE_NAPI_FUNCTION("isNotNull", IsNotNull),
53         DECLARE_NAPI_FUNCTION("like", Like),
54         DECLARE_NAPI_FUNCTION("unlike", Unlike),
55         DECLARE_NAPI_FUNCTION("glob", Glob),
56         DECLARE_NAPI_FUNCTION("between", Between),
57         DECLARE_NAPI_FUNCTION("notBetween", NotBetween),
58         DECLARE_NAPI_FUNCTION("greaterThan", GreaterThan),
59         DECLARE_NAPI_FUNCTION("lessThan", LessThan),
60         DECLARE_NAPI_FUNCTION("greaterThanOrEqualTo", GreaterThanOrEqualTo),
61         DECLARE_NAPI_FUNCTION("lessThanOrEqualTo", LessThanOrEqualTo),
62         DECLARE_NAPI_FUNCTION("orderByAsc", OrderByAsc),
63         DECLARE_NAPI_FUNCTION("orderByDesc", OrderByDesc),
64         DECLARE_NAPI_FUNCTION("distinct", Distinct),
65         DECLARE_NAPI_FUNCTION("limit", Limit),
66         DECLARE_NAPI_FUNCTION("groupBy", GroupBy),
67         DECLARE_NAPI_FUNCTION("indexedBy", IndexedBy),
68         DECLARE_NAPI_FUNCTION("in", In),
69         DECLARE_NAPI_FUNCTION("notIn", NotIn),
70         DECLARE_NAPI_FUNCTION("prefixKey", PrefixKey),
71         DECLARE_NAPI_FUNCTION("inKeys", InKeys),
72     };
73     int64_t start = std::chrono::duration_cast<std::chrono::milliseconds>(
74         std::chrono::system_clock::now().time_since_epoch()).count();
75     NAPI_CALL(env, napi_define_class(env, "DataSharePredicates", NAPI_AUTO_LENGTH, New, nullptr,
76         sizeof(descriptors) / sizeof(napi_property_descriptor), descriptors, &cons));
77     int64_t middle = std::chrono::duration_cast<std::chrono::milliseconds>(
78         std::chrono::system_clock::now().time_since_epoch()).count();
79     NAPI_CALL(env, napi_create_reference(env, cons, 1, &constructor_));
80     int64_t finish = std::chrono::duration_cast<std::chrono::milliseconds>(
81         std::chrono::system_clock::now().time_since_epoch()).count();
82     LOG_INFO("Init predicates create reference, cost time: %{public}" PRIi64
83         "ms , cost time:%{public}" PRIi64 "ms", middle - start, finish - middle);
84     return cons;
85 }
86 
Init(napi_env env,napi_value exports)87 void DataSharePredicatesProxy::Init(napi_env env, napi_value exports)
88 {
89     // In asan version, the thread underline maybe reused and thread-local may not be cleared, this will
90     // cause use-after-free.
91     constructor_ = nullptr;
92     napi_value cons = GetConstructor(env);
93     int64_t start = std::chrono::duration_cast<std::chrono::milliseconds>(
94         std::chrono::system_clock::now().time_since_epoch()).count();
95     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "DataSharePredicates", cons));
96     int64_t end = std::chrono::duration_cast<std::chrono::milliseconds>(
97         std::chrono::system_clock::now().time_since_epoch()).count();
98     LOG_INFO("Init predicates set named property, cost time:%{public}" PRIi64 "ms", end - start);
99 }
100 
New(napi_env env,napi_callback_info info)101 napi_value DataSharePredicatesProxy::New(napi_env env, napi_callback_info info)
102 {
103     napi_value new_target;
104     NAPI_CALL(env, napi_get_new_target(env, info, &new_target));
105     bool is_constructor = (new_target != nullptr);
106 
107     napi_value thiz;
108     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr));
109 
110     if (is_constructor) {
111         auto *proxy = new (std::nothrow) DataSharePredicatesProxy();
112         if (proxy == nullptr) {
113             LOG_ERROR("DataSharePredicatesProxy::New new DataSharePredicatesProxy error.");
114             return nullptr;
115         }
116         proxy->SetInstance(std::make_shared<DataSharePredicates>());
117         napi_status ret = napi_wrap(env, thiz, proxy, DataSharePredicatesProxy::Destructor, nullptr, nullptr);
118         if (ret != napi_ok) {
119             delete proxy;
120             LOG_ERROR("napi_wrap error");
121             return nullptr;
122         }
123         return thiz;
124     }
125 
126     napi_value cons = GetConstructor(env);
127     if (cons == nullptr) {
128         LOG_ERROR("GetConstructor failed.");
129         return nullptr;
130     }
131 
132     napi_value output;
133     NAPI_CALL(env, napi_new_instance(env, cons, 0, nullptr, &output));
134 
135     return output;
136 }
137 
NewInstance(napi_env env,std::shared_ptr<DataShareAbsPredicates> value)138 napi_value DataSharePredicatesProxy::NewInstance(napi_env env, std::shared_ptr<DataShareAbsPredicates> value)
139 {
140     napi_value cons = GetConstructor(env);
141     if (cons == nullptr) {
142         LOG_ERROR("GetConstructor failed.");
143         return nullptr;
144     }
145 
146     napi_value instance = nullptr;
147     napi_status status = napi_new_instance(env, cons, 0, nullptr, &instance);
148     if (status != napi_ok) {
149         LOG_ERROR("napi_new_instance failed! napi_status:%{public}d!", status);
150         return nullptr;
151     }
152 
153     DataSharePredicatesProxy *proxy = nullptr;
154     status = napi_unwrap(env, instance, reinterpret_cast<void **>(&proxy));
155     if (status != napi_ok) {
156         LOG_ERROR("native instance is nullptr! napi_status:%{public}d!", status);
157         return instance;
158     }
159     if (proxy == nullptr) {
160         LOG_ERROR("Native Predicates is nullptr!");
161         return nullptr;
162     }
163     proxy->SetInstance(value);
164     return instance;
165 }
166 
GetNativePredicates(const napi_env env,const napi_value arg)167 std::shared_ptr<DataShareAbsPredicates> DataSharePredicatesProxy::GetNativePredicates(
168     const napi_env env, const napi_value arg)
169 {
170     if (arg == nullptr) {
171         LOG_ERROR("arg is null.");
172         return nullptr;
173     }
174     DataSharePredicatesProxy *proxy = nullptr;
175     napi_unwrap(env, arg, reinterpret_cast<void **>(&proxy));
176     if (proxy == nullptr) {
177         LOG_ERROR("Native Predicates is nullptr!");
178         return nullptr;
179     }
180     return proxy->GetInstance();
181 }
182 
Destructor(napi_env env,void * nativeObject,void *)183 void DataSharePredicatesProxy::Destructor(napi_env env, void *nativeObject, void *)
184 {
185     DataSharePredicatesProxy *proxy = static_cast<DataSharePredicatesProxy *>(nativeObject);
186     delete proxy;
187 }
188 
~DataSharePredicatesProxy()189 DataSharePredicatesProxy::~DataSharePredicatesProxy()
190 {
191     SetInstance(nullptr);
192 }
193 
DataSharePredicatesProxy()194 DataSharePredicatesProxy::DataSharePredicatesProxy()
195 {
196 }
197 
GetNativePredicates(napi_env env,napi_callback_info info)198 std::shared_ptr<DataShareAbsPredicates> DataSharePredicatesProxy::GetNativePredicates(
199     napi_env env, napi_callback_info info)
200 {
201     DataSharePredicatesProxy *predicatesProxy = nullptr;
202     napi_value thiz;
203     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
204     napi_unwrap(env, thiz, reinterpret_cast<void **>(&predicatesProxy));
205     if (predicatesProxy == nullptr) {
206         LOG_ERROR("predicatesProxy is nullptr!");
207         return nullptr;
208     }
209     return predicatesProxy->GetInstance();
210 }
211 
EqualTo(napi_env env,napi_callback_info info)212 napi_value DataSharePredicatesProxy::EqualTo(napi_env env, napi_callback_info info)
213 {
214     napi_value thiz;
215     size_t argc = 2;
216     napi_value args[2] = { 0 };
217     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
218     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
219     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
220     napi_valuetype valueType = napi_undefined;
221     napi_status status = napi_typeof(env, args[1], &valueType);
222     if (status != napi_ok) {
223         LOG_ERROR("napi_typeof status : %{public}d", status);
224         return thiz;
225     }
226     auto nativePredicates = GetNativePredicates(env, info);
227     if (nativePredicates == nullptr) {
228         LOG_ERROR("GetNativePredicates failed.");
229         return thiz;
230     }
231     switch (valueType) {
232         case napi_number: {
233             double value;
234             napi_get_value_double(env, args[1], &value);
235             nativePredicates->EqualTo(field, value);
236             break;
237         }
238         case napi_boolean: {
239             bool value = false;
240             napi_get_value_bool(env, args[1], &value);
241             nativePredicates->EqualTo(field, value);
242             break;
243         }
244         case napi_string: {
245             std::string value = DataShareJSUtils::Convert2String(env, args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
246             nativePredicates->EqualTo(field, value);
247             break;
248         }
249         default:
250             break;
251     }
252     return thiz;
253 }
254 
NotEqualTo(napi_env env,napi_callback_info info)255 napi_value DataSharePredicatesProxy::NotEqualTo(napi_env env, napi_callback_info info)
256 {
257     napi_value thiz;
258     size_t argc = 2;
259     napi_value args[2] = { 0 };
260     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
261     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
262     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
263     napi_valuetype valueType = napi_undefined;
264     napi_status status = napi_typeof(env, args[1], &valueType);
265     if (status != napi_ok) {
266         LOG_ERROR("napi_typeof status : %{public}d", status);
267         return thiz;
268     }
269     auto nativePredicates = GetNativePredicates(env, info);
270     if (nativePredicates == nullptr) {
271         LOG_ERROR("GetNativePredicates failed.");
272         return thiz;
273     }
274     switch (valueType) {
275         case napi_number: {
276             double value;
277             napi_get_value_double(env, args[1], &value);
278             nativePredicates->NotEqualTo(field, value);
279             break;
280         }
281         case napi_boolean: {
282             bool value = false;
283             napi_get_value_bool(env, args[1], &value);
284             nativePredicates->NotEqualTo(field, value);
285             break;
286         }
287         case napi_string: {
288             std::string value = DataShareJSUtils::Convert2String(env, args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
289             nativePredicates->NotEqualTo(field, value);
290             break;
291         }
292         default:
293             break;
294     }
295     return thiz;
296 }
297 
BeginWrap(napi_env env,napi_callback_info info)298 napi_value DataSharePredicatesProxy::BeginWrap(napi_env env, napi_callback_info info)
299 {
300     napi_value thiz;
301     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
302     auto nativePredicates = GetNativePredicates(env, info);
303     if (nativePredicates == nullptr) {
304         LOG_ERROR("GetNativePredicates failed.");
305         return thiz;
306     }
307     nativePredicates->BeginWrap();
308     return thiz;
309 }
310 
EndWrap(napi_env env,napi_callback_info info)311 napi_value DataSharePredicatesProxy::EndWrap(napi_env env, napi_callback_info info)
312 {
313     napi_value thiz;
314     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
315     auto nativePredicates = GetNativePredicates(env, info);
316     if (nativePredicates == nullptr) {
317         LOG_ERROR("GetNativePredicates failed.");
318         return thiz;
319     }
320     nativePredicates->EndWrap();
321     return thiz;
322 }
323 
Or(napi_env env,napi_callback_info info)324 napi_value DataSharePredicatesProxy::Or(napi_env env, napi_callback_info info)
325 {
326     napi_value thiz;
327     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
328     auto nativePredicates = GetNativePredicates(env, info);
329     if (nativePredicates == nullptr) {
330         LOG_ERROR("GetNativePredicates failed.");
331         return thiz;
332     }
333     nativePredicates->Or();
334     return thiz;
335 }
336 
And(napi_env env,napi_callback_info info)337 napi_value DataSharePredicatesProxy::And(napi_env env, napi_callback_info info)
338 {
339     napi_value thiz;
340     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
341     auto nativePredicates = GetNativePredicates(env, info);
342     if (nativePredicates == nullptr) {
343         LOG_ERROR("GetNativePredicates failed.");
344         return thiz;
345     }
346     nativePredicates->And();
347     return thiz;
348 }
349 
Contains(napi_env env,napi_callback_info info)350 napi_value DataSharePredicatesProxy::Contains(napi_env env, napi_callback_info info)
351 {
352     napi_value thiz;
353     size_t argc = 2;
354     napi_value args[2] = { 0 };
355     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
356     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
357     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
358     std::string value = DataShareJSUtils::ConvertAny2String(env, args[1]);
359 
360     auto nativePredicates = GetNativePredicates(env, info);
361     if (nativePredicates == nullptr) {
362         LOG_ERROR("GetNativePredicates failed.");
363         return thiz;
364     }
365     nativePredicates->Contains(field, value);
366     return thiz;
367 }
368 
BeginsWith(napi_env env,napi_callback_info info)369 napi_value DataSharePredicatesProxy::BeginsWith(napi_env env, napi_callback_info info)
370 {
371     napi_value thiz;
372     size_t argc = 2;
373     napi_value args[2] = { 0 };
374     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
375     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
376     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
377     std::string value = DataShareJSUtils::ConvertAny2String(env, args[1]);
378     auto nativePredicates = GetNativePredicates(env, info);
379     if (nativePredicates == nullptr) {
380         LOG_ERROR("GetNativePredicates failed.");
381         return thiz;
382     }
383     nativePredicates->BeginsWith(field, value);
384     return thiz;
385 }
386 
EndsWith(napi_env env,napi_callback_info info)387 napi_value DataSharePredicatesProxy::EndsWith(napi_env env, napi_callback_info info)
388 {
389     napi_value thiz;
390     size_t argc = 2;
391     napi_value args[2] = { 0 };
392     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
393     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
394     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
395     std::string value = DataShareJSUtils::ConvertAny2String(env, args[1]);
396     auto nativePredicates = GetNativePredicates(env, info);
397     if (nativePredicates == nullptr) {
398         LOG_ERROR("GetNativePredicates failed.");
399         return thiz;
400     }
401     nativePredicates->EndsWith(field, value);
402     return thiz;
403 }
404 
IsNull(napi_env env,napi_callback_info info)405 napi_value DataSharePredicatesProxy::IsNull(napi_env env, napi_callback_info info)
406 {
407     napi_value thiz;
408     size_t argc = 1;
409     napi_value args[1] = { 0 };
410     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
411     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
412     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
413     auto nativePredicates = GetNativePredicates(env, info);
414     if (nativePredicates == nullptr) {
415         LOG_ERROR("GetNativePredicates failed.");
416         return thiz;
417     }
418     nativePredicates->IsNull(field);
419     return thiz;
420 }
421 
IsNotNull(napi_env env,napi_callback_info info)422 napi_value DataSharePredicatesProxy::IsNotNull(napi_env env, napi_callback_info info)
423 {
424     napi_value thiz;
425     size_t argc = 1;
426     napi_value args[1] = { 0 };
427     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
428     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
429     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
430     auto nativePredicates = GetNativePredicates(env, info);
431     if (nativePredicates == nullptr) {
432         LOG_ERROR("GetNativePredicates failed.");
433         return thiz;
434     }
435     nativePredicates->IsNotNull(field);
436     return thiz;
437 }
438 
Like(napi_env env,napi_callback_info info)439 napi_value DataSharePredicatesProxy::Like(napi_env env, napi_callback_info info)
440 {
441     napi_value thiz;
442     size_t argc = 2;
443     napi_value args[2] = { 0 };
444     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
445     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
446     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
447     std::string value = DataShareJSUtils::ConvertAny2String(env, args[1]);
448     auto nativePredicates = GetNativePredicates(env, info);
449     if (nativePredicates == nullptr) {
450         LOG_ERROR("GetNativePredicates failed.");
451         return thiz;
452     }
453     nativePredicates->Like(field, value);
454     return thiz;
455 }
456 
Unlike(napi_env env,napi_callback_info info)457 napi_value DataSharePredicatesProxy::Unlike(napi_env env, napi_callback_info info)
458 {
459     napi_value thiz;
460     size_t argc = 2;
461     napi_value args[2] = { 0 };
462     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
463     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
464     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
465     std::string value = DataShareJSUtils::ConvertAny2String(env, args[1]);
466     auto nativePredicates = GetNativePredicates(env, info);
467     if (nativePredicates == nullptr) {
468         LOG_ERROR("GetNativePredicates failed.");
469         return thiz;
470     }
471     nativePredicates->Unlike(field, value);
472     return thiz;
473 }
474 
Glob(napi_env env,napi_callback_info info)475 napi_value DataSharePredicatesProxy::Glob(napi_env env, napi_callback_info info)
476 {
477     napi_value thiz;
478     size_t argc = 2;
479     napi_value args[2] = { 0 };
480     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
481     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
482     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
483     std::string value = DataShareJSUtils::ConvertAny2String(env, args[1]);
484     auto nativePredicates = GetNativePredicates(env, info);
485     if (nativePredicates == nullptr) {
486         LOG_ERROR("GetNativePredicates failed.");
487         return thiz;
488     }
489     nativePredicates->Glob(field, value);
490     return thiz;
491 }
492 
Between(napi_env env,napi_callback_info info)493 napi_value DataSharePredicatesProxy::Between(napi_env env, napi_callback_info info)
494 {
495     napi_value thiz;
496     size_t argc = 3;
497     napi_value args[3] = { 0 };
498     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
499     //'argc > 2' represents determine if 'argc' is greater than '2'
500     NAPI_ASSERT(env, argc > 2, "Invalid argvs!");
501     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
502     std::string low = DataShareJSUtils::ConvertAny2String(env, args[1]);
503     std::string high = DataShareJSUtils::ConvertAny2String(env, args[2]);
504     auto nativePredicates = GetNativePredicates(env, info);
505     if (nativePredicates == nullptr) {
506         LOG_ERROR("GetNativePredicates failed.");
507         return thiz;
508     }
509     nativePredicates->Between(field, low, high);
510     return thiz;
511 }
512 
NotBetween(napi_env env,napi_callback_info info)513 napi_value DataSharePredicatesProxy::NotBetween(napi_env env, napi_callback_info info)
514 {
515     napi_value thiz;
516     size_t argc = 3;
517     napi_value args[3] = { 0 };
518     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
519     //'argc > 2' represents determine if 'argc' is greater than '2'
520     NAPI_ASSERT(env, argc > 2, "Invalid argvs!");
521     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
522     std::string low = DataShareJSUtils::ConvertAny2String(env, args[1]);
523     std::string high = DataShareJSUtils::ConvertAny2String(env, args[2]);
524     auto nativePredicates = GetNativePredicates(env, info);
525     if (nativePredicates == nullptr) {
526         LOG_ERROR("GetNativePredicates failed.");
527         return thiz;
528     }
529     nativePredicates->NotBetween(field, low, high);
530     return thiz;
531 }
532 
GreaterThan(napi_env env,napi_callback_info info)533 napi_value DataSharePredicatesProxy::GreaterThan(napi_env env, napi_callback_info info)
534 {
535     napi_value thiz;
536     size_t argc = 2;
537     napi_value args[2] = { 0 };
538     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
539     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
540     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
541     napi_valuetype valueType = napi_undefined;
542     napi_status status = napi_typeof(env, args[1], &valueType);
543     if (status != napi_ok) {
544         LOG_ERROR("napi_typeof status : %{public}d", status);
545         return thiz;
546     }
547     auto nativePredicates = GetNativePredicates(env, info);
548     if (nativePredicates == nullptr) {
549         LOG_ERROR("GetNativePredicates failed.");
550         return thiz;
551     }
552     switch (valueType) {
553         case napi_number: {
554             double value;
555             napi_get_value_double(env, args[1], &value);
556             nativePredicates->GreaterThan(field, value);
557             break;
558         }
559         case napi_string: {
560             std::string value = DataShareJSUtils::Convert2String(env, args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
561             nativePredicates->GreaterThan(field, value);
562             break;
563         }
564         default:
565             break;
566     }
567     return thiz;
568 }
569 
LessThan(napi_env env,napi_callback_info info)570 napi_value DataSharePredicatesProxy::LessThan(napi_env env, napi_callback_info info)
571 {
572     napi_value thiz;
573     size_t argc = 2;
574     napi_value args[2] = { 0 };
575     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
576     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
577     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
578     napi_valuetype valueType = napi_undefined;
579     napi_status status = napi_typeof(env, args[1], &valueType);
580     if (status != napi_ok) {
581         LOG_ERROR("napi_typeof status : %{public}d", status);
582         return thiz;
583     }
584     auto nativePredicates = GetNativePredicates(env, info);
585     if (nativePredicates == nullptr) {
586         LOG_ERROR("GetNativePredicates failed.");
587         return thiz;
588     }
589     switch (valueType) {
590         case napi_number: {
591             double value;
592             napi_get_value_double(env, args[1], &value);
593             nativePredicates->LessThan(field, value);
594             break;
595         }
596         case napi_string: {
597             std::string value = DataShareJSUtils::Convert2String(env, args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
598             nativePredicates->LessThan(field, value);
599             break;
600         }
601         default:
602             break;
603     }
604     return thiz;
605 }
606 
GreaterThanOrEqualTo(napi_env env,napi_callback_info info)607 napi_value DataSharePredicatesProxy::GreaterThanOrEqualTo(napi_env env, napi_callback_info info)
608 {
609     napi_value thiz;
610     size_t argc = 2;
611     napi_value args[2] = { 0 };
612     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
613     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
614     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
615     napi_valuetype valueType = napi_undefined;
616     napi_status status = napi_typeof(env, args[1], &valueType);
617     if (status != napi_ok) {
618         LOG_ERROR("napi_typeof status : %{public}d", status);
619         return thiz;
620     }
621     auto nativePredicates = GetNativePredicates(env, info);
622     if (nativePredicates == nullptr) {
623         LOG_ERROR("GetNativePredicates failed.");
624         return thiz;
625     }
626     switch (valueType) {
627         case napi_number: {
628             double value;
629             napi_get_value_double(env, args[1], &value);
630             nativePredicates->GreaterThanOrEqualTo(field, value);
631             break;
632         }
633         case napi_string: {
634             std::string value = DataShareJSUtils::Convert2String(env, args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
635             nativePredicates->GreaterThanOrEqualTo(field, value);
636             break;
637         }
638         default:
639             break;
640     }
641     return thiz;
642 }
643 
LessThanOrEqualTo(napi_env env,napi_callback_info info)644 napi_value DataSharePredicatesProxy::LessThanOrEqualTo(napi_env env, napi_callback_info info)
645 {
646     napi_value thiz;
647     size_t argc = 2;
648     napi_value args[2] = { 0 };
649     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
650     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
651     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
652     napi_valuetype valueType = napi_undefined;
653     napi_status status = napi_typeof(env, args[1], &valueType);
654     if (status != napi_ok) {
655         LOG_ERROR("napi_typeof status : %{public}d", status);
656         return thiz;
657     }
658     auto nativePredicates = GetNativePredicates(env, info);
659     if (nativePredicates == nullptr) {
660         LOG_ERROR("GetNativePredicates failed.");
661         return thiz;
662     }
663     switch (valueType) {
664         case napi_number: {
665             double value;
666             napi_get_value_double(env, args[1], &value);
667             nativePredicates->LessThanOrEqualTo(field, value);
668             break;
669         }
670         case napi_string: {
671             std::string value = DataShareJSUtils::Convert2String(env, args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
672             nativePredicates->LessThanOrEqualTo(field, value);
673             break;
674         }
675         default:
676             break;
677     }
678     return thiz;
679 }
680 
OrderByAsc(napi_env env,napi_callback_info info)681 napi_value DataSharePredicatesProxy::OrderByAsc(napi_env env, napi_callback_info info)
682 {
683     napi_value thiz;
684     size_t argc = 1;
685     napi_value args[1] = { 0 };
686     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
687     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
688     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
689     auto nativePredicates = GetNativePredicates(env, info);
690     if (nativePredicates == nullptr) {
691         LOG_ERROR("GetNativePredicates failed.");
692         return thiz;
693     }
694     nativePredicates->OrderByAsc(field);
695     return thiz;
696 }
697 
OrderByDesc(napi_env env,napi_callback_info info)698 napi_value DataSharePredicatesProxy::OrderByDesc(napi_env env, napi_callback_info info)
699 {
700     napi_value thiz;
701     size_t argc = 1;
702     napi_value args[1] = { 0 };
703     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
704     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
705     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
706     auto nativePredicates = GetNativePredicates(env, info);
707     if (nativePredicates == nullptr) {
708         LOG_ERROR("GetNativePredicates failed.");
709         return thiz;
710     }
711     nativePredicates->OrderByDesc(field);
712     return thiz;
713 }
714 
Distinct(napi_env env,napi_callback_info info)715 napi_value DataSharePredicatesProxy::Distinct(napi_env env, napi_callback_info info)
716 {
717     napi_value thiz;
718     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
719     auto nativePredicates = GetNativePredicates(env, info);
720     if (nativePredicates == nullptr) {
721         LOG_ERROR("GetNativePredicates failed.");
722         return thiz;
723     }
724     nativePredicates->Distinct();
725     return thiz;
726 }
727 
Limit(napi_env env,napi_callback_info info)728 napi_value DataSharePredicatesProxy::Limit(napi_env env, napi_callback_info info)
729 {
730     napi_value thiz;
731     size_t argc = 2;
732     napi_value args[2] = { 0 };
733     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
734     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
735     int number = 0;
736     napi_get_value_int32(env, args[0], &number);
737     int offset = 0;
738     napi_get_value_int32(env, args[1], &offset);
739     auto nativePredicates = GetNativePredicates(env, info);
740     if (nativePredicates == nullptr) {
741         LOG_ERROR("GetNativePredicates failed.");
742         return thiz;
743     }
744     nativePredicates->Limit(number, offset);
745     return thiz;
746 }
747 
GroupBy(napi_env env,napi_callback_info info)748 napi_value DataSharePredicatesProxy::GroupBy(napi_env env, napi_callback_info info)
749 {
750     napi_value thiz;
751     size_t argc = 1;
752     napi_value args[1] = { 0 };
753     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
754     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
755     std::vector<std::string> fields = DataShareJSUtils::Convert2StrVector(env,
756         args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
757     auto nativePredicates = GetNativePredicates(env, info);
758     if (nativePredicates == nullptr) {
759         LOG_ERROR("GetNativePredicates failed.");
760         return thiz;
761     }
762     nativePredicates->GroupBy(fields);
763     return thiz;
764 }
765 
IndexedBy(napi_env env,napi_callback_info info)766 napi_value DataSharePredicatesProxy::IndexedBy(napi_env env, napi_callback_info info)
767 {
768     napi_value thiz;
769     size_t argc = 1;
770     napi_value args[1] = { 0 };
771     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
772     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
773     std::string indexName = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
774     auto nativePredicates = GetNativePredicates(env, info);
775     if (nativePredicates == nullptr) {
776         LOG_ERROR("GetNativePredicates failed.");
777         return thiz;
778     }
779     nativePredicates->IndexedBy(indexName);
780     return thiz;
781 }
782 
In(napi_env env,napi_callback_info info)783 napi_value DataSharePredicatesProxy::In(napi_env env, napi_callback_info info)
784 {
785     napi_value thiz;
786     size_t argc = 2;
787     napi_value args[2] = { 0 };
788     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
789     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
790     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
791     std::vector<std::string> values = DataShareJSUtils::Convert2StrVector(env,
792         args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
793     auto nativePredicates = GetNativePredicates(env, info);
794     if (nativePredicates == nullptr) {
795         LOG_ERROR("GetNativePredicates failed.");
796         return thiz;
797     }
798     nativePredicates->In(field, values);
799     return thiz;
800 }
801 
NotIn(napi_env env,napi_callback_info info)802 napi_value DataSharePredicatesProxy::NotIn(napi_env env, napi_callback_info info)
803 {
804     napi_value thiz;
805     size_t argc = 2;
806     napi_value args[2] = { 0 };
807     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
808     NAPI_ASSERT(env, argc > 1, "Invalid argvs!");
809     std::string field = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
810     std::vector<std::string> values = DataShareJSUtils::Convert2StrVector(env,
811         args[1], DataShareJSUtils::DEFAULT_BUF_SIZE);
812     auto nativePredicates = GetNativePredicates(env, info);
813     if (nativePredicates == nullptr) {
814         LOG_ERROR("GetNativePredicates failed.");
815         return thiz;
816     }
817     nativePredicates->NotIn(field, values);
818     return thiz;
819 }
820 
PrefixKey(napi_env env,napi_callback_info info)821 napi_value DataSharePredicatesProxy::PrefixKey(napi_env env, napi_callback_info info)
822 {
823     napi_value thiz;
824     size_t argc = 1;
825     napi_value args[1] = { 0 };
826     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
827     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
828     std::string prefix = DataShareJSUtils::Convert2String(env, args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
829     auto nativePredicates = GetNativePredicates(env, info);
830     if (nativePredicates == nullptr) {
831         LOG_ERROR("GetNativePredicates failed.");
832         return thiz;
833     }
834     nativePredicates->KeyPrefix(prefix);
835     return thiz;
836 }
837 
InKeys(napi_env env,napi_callback_info info)838 napi_value DataSharePredicatesProxy::InKeys(napi_env env, napi_callback_info info)
839 {
840     napi_value thiz;
841     size_t argc = 1;
842     napi_value args[1] = { 0 };
843     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
844     NAPI_ASSERT(env, argc > 0, "Invalid argvs!");
845     std::vector<std::string> keys = DataShareJSUtils::Convert2StrVector(env,
846         args[0], DataShareJSUtils::DEFAULT_BUF_SIZE);
847     auto nativePredicates = GetNativePredicates(env, info);
848     if (nativePredicates == nullptr) {
849         LOG_ERROR("GetNativePredicates failed.");
850         return thiz;
851     }
852     nativePredicates->InKeys(keys);
853     return thiz;
854 }
855 } // namespace DataShare
856 } // namespace OHOS