1 /*
2 * Copyright (c) 2023 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 #include <iostream>
16 #include <stdio.h>
17 #include <unistd.h>
18 #include <string>
19 #include <string.h>
20 #include <cstdio>
21 #include <cstdlib>
22 #include <fcntl.h>
23 #include <securec.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26
27 #include "napi/native_api.h"
28 #include "common/common.h"
29 #include "relational_store.h"
30 #include "relational_store_error_code.h"
31 #include "oh_cursor.h"
32 #include "oh_predicates.h"
33 #include "oh_value_object.h"
34 #include "oh_values_bucket.h"
35
36 OH_Rdb_Store *predicatesTestRdbStore_ = NULL;
37
38 char *RDB_TEST_PATH = NULL;
39 char RDB_STORE_NAME[] = "rdb_store_predicates_test.db";
40 char BUNDLE_NAME[] = "com.acts.rdb.napitest";
41 char MODULE_NAME[] = "com.acts.rdb.napitest";
42
43 static OH_Rdb_Config config_;
InitRdbConfig()44 static void InitRdbConfig()
45 {
46 config_.dataBaseDir = RDB_TEST_PATH;
47 config_.storeName = RDB_STORE_NAME;
48 config_.bundleName = BUNDLE_NAME;
49 config_.moduleName = MODULE_NAME;
50 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
51 config_.isEncrypt = false;
52 config_.selfSize = sizeof(OH_Rdb_Config);
53 }
54
RdbFilePath(napi_env env,napi_callback_info info)55 static napi_value RdbFilePath(napi_env env, napi_callback_info info) {
56 int errCode = 0;
57 size_t argc = 1;
58 napi_value args[1] = {nullptr};
59 napi_get_cb_info(env, info, &argc, args , nullptr, nullptr);
60
61 size_t bufferSize = 0;
62 napi_get_value_string_latin1(env, args[0], nullptr, 0, &bufferSize);
63
64 char *buffer = (char*)malloc((bufferSize) + 1);
65 napi_get_value_string_utf8(env, args[0], buffer, bufferSize+1, &bufferSize);
66
67 RDB_TEST_PATH = (char*)malloc((bufferSize) + 1);
68 sprintf(RDB_TEST_PATH, "%s", buffer);
69
70 napi_value returnCode;
71 napi_create_double(env, errCode, &returnCode);
72 return returnCode;
73 }
74
PredicatesSetUpTestCase(napi_env env,napi_callback_info info)75 static napi_value PredicatesSetUpTestCase(napi_env env, napi_callback_info info) {
76 InitRdbConfig();
77 mkdir(config_.dataBaseDir, 0770);
78
79 int errCode = 0;
80 char table[] = "test";
81 predicatesTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
82 NAPI_ASSERT(env, predicatesTestRdbStore_ != NULL, "OH_Rdb_GetOrOpen is fail.");
83
84 char createTableSql[] = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
85 "data3 FLOAT, data4 BLOB, data5 TEXT);";
86 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, createTableSql);
87
88 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
89 valueBucket->putInt64(valueBucket, "id", 1);
90 valueBucket->putText(valueBucket, "data1", "zhangSan");
91 valueBucket->putInt64(valueBucket, "data2", 12800);
92 valueBucket->putReal(valueBucket, "data3", 100.1);
93 uint8_t arr[] = {1, 2, 3, 4, 5};
94 int len = sizeof(arr) / sizeof(arr[0]);
95 valueBucket->putBlob(valueBucket, "data4", arr, len);
96 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
97 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
98 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert 1 is fail.");
99
100 valueBucket->clear(valueBucket);
101 valueBucket->putInt64(valueBucket, "id", 2);
102 valueBucket->putText(valueBucket, "data1", "liSi");
103 valueBucket->putInt64(valueBucket, "data2", 13800);
104 valueBucket->putReal(valueBucket, "data3", 200.1);
105 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
106 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
107 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert 2 is fail.");
108
109 valueBucket->clear(valueBucket);
110 valueBucket->putInt64(valueBucket, "id", 3);
111 valueBucket->putText(valueBucket, "data1", "wangWu");
112 valueBucket->putInt64(valueBucket, "data2", 14800);
113 valueBucket->putReal(valueBucket, "data3", 300.1);
114 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
115 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
116 NAPI_ASSERT(env, errCode == 3, "OH_Rdb_Insert 3 is fail.");
117
118 valueBucket->clear(valueBucket);
119 valueBucket->putInt64(valueBucket, "id", 4);
120 valueBucket->putText(valueBucket, "data1", "zhangliu");
121 valueBucket->putInt64(valueBucket, "data2", 14800);
122 valueBucket->putReal(valueBucket, "data3", 300.1);
123 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
124 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
125 NAPI_ASSERT(env, errCode == 4, "OH_Rdb_Insert 4 is fail.");
126
127 errCode = 0;
128 napi_value returnCode;
129 napi_create_double(env, errCode, &returnCode);
130 return returnCode;
131
132 }
133
PredicatesTearDownTestCase(napi_env env,napi_callback_info info)134 static napi_value PredicatesTearDownTestCase(napi_env env, napi_callback_info info) {
135 int errCode = 0;
136 char dropTableSql[] = "DROP TABLE IF EXISTS test";
137 OH_Rdb_Execute(predicatesTestRdbStore_, dropTableSql);
138 OH_Rdb_CloseStore(predicatesTestRdbStore_);
139 errCode = OH_Rdb_DeleteStore(&config_);
140 napi_value returnCode;
141 napi_create_double(env, errCode, &returnCode);
142 return returnCode;
143
144 }
145
146
147 /**
148 * @tc.name: SUB_DDM_RDB_Predicates_0100
149 * @tc.desc: napi test RDB Predicates for EqualTo、AndOR、beginWrap and endWrap
150 * @tc.type: FUNC
151 */
SUB_DDM_RDB_Predicates_0100(napi_env env,napi_callback_info info)152 static napi_value SUB_DDM_RDB_Predicates_0100(napi_env env, napi_callback_info info) {
153 int errCode = 0;
154 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
155 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
156 uint32_t count = 1;
157 const char *data1Value = "zhangSan";
158 valueObject->putText(valueObject, data1Value);
159 predicates->beginWrap(predicates);
160 predicates->equalTo(predicates, "data1", valueObject);
161 predicates->orOperate(predicates);
162 double data3Value = 200.1;
163 valueObject->putDouble(valueObject, &data3Value, count);
164 predicates->equalTo(predicates, "data3", valueObject);
165 predicates->endWrap(predicates);
166
167 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
168 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
169
170 int rowCount = 0;
171 errCode = cursor->getRowCount(cursor, &rowCount);
172 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
173
174 predicates->destroy(predicates);
175 valueObject->destroy(valueObject);
176 errCode = cursor->destroy(cursor);
177
178 napi_value returnCode;
179 napi_create_double(env, errCode, &returnCode);
180 return returnCode;
181 }
182
183 /**
184 * @tc.name: SUB_DDM_RDB_Predicates_0200
185 * @tc.desc: napi test RDB Predicates for NotEqualTo
186 * @tc.type: FUNC
187 */
SUB_DDM_RDB_Predicates_0200(napi_env env,napi_callback_info info)188 static napi_value SUB_DDM_RDB_Predicates_0200(napi_env env, napi_callback_info info) {
189 int errCode = 0;
190 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
191 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
192 const char *data1Value = "zhangSan";
193 valueObject->putText(valueObject, data1Value);
194 predicates->notEqualTo(predicates, "data1", valueObject);
195 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
196 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
197 int rowCount = 0;
198 errCode = cursor->getRowCount(cursor, &rowCount);
199 NAPI_ASSERT(env, rowCount == 3, "getRowCount is fail.");
200
201 valueObject->destroy(valueObject);
202 predicates->destroy(predicates);
203 errCode = cursor->destroy(cursor);
204
205 napi_value returnCode;
206 napi_create_double(env, errCode, &returnCode);
207 return returnCode;
208 }
209
210
211 /**
212 * @tc.name: SUB_DDM_RDB_Predicates_0300
213 * @tc.desc: napi test RDB Predicates for GreaterThan
214 * @tc.type: FUNC
215 */
SUB_DDM_RDB_Predicates_0300(napi_env env,napi_callback_info info)216 static napi_value SUB_DDM_RDB_Predicates_0300(napi_env env, napi_callback_info info) {
217 int errCode = 0;
218 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
219 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
220 const char *data5Value = "ABCDEFG";
221 valueObject->putText(valueObject, data5Value);
222 predicates->greaterThan(predicates, "data5", valueObject);
223
224 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
225 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
226 int rowCount = 0;
227 errCode = cursor->getRowCount(cursor, &rowCount);
228 NAPI_ASSERT(env, rowCount == 3, "getRowCount is fail.");
229
230 valueObject->destroy(valueObject);
231 predicates->destroy(predicates);
232 errCode = cursor->destroy(cursor);
233
234 napi_value returnCode;
235 napi_create_double(env, errCode, &returnCode);
236 return returnCode;
237 }
238 /**
239 * @tc.name: SUB_DDM_RDB_Predicates_0400
240 * @tc.desc: napi test RDB Predicates for GreaterThanOrEqualTo
241 * @tc.type: FUNC
242 */
SUB_DDM_RDB_Predicates_0400(napi_env env,napi_callback_info info)243 static napi_value SUB_DDM_RDB_Predicates_0400(napi_env env, napi_callback_info info) {
244 int errCode = 0;
245 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
246 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
247 const char *data5Value = "ABCDEFG";
248 valueObject->putText(valueObject, data5Value);
249 predicates->greaterThanOrEqualTo(predicates, "data5", valueObject);
250
251 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
252 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
253 int rowCount = 0;
254 errCode = cursor->getRowCount(cursor, &rowCount);
255 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
256
257 valueObject->destroy(valueObject);
258 predicates->destroy(predicates);
259 errCode = cursor->destroy(cursor);
260
261 napi_value returnCode;
262 napi_create_double(env, errCode, &returnCode);
263 return returnCode;
264 }
265
266
267
268 /**
269 * @tc.name: SUB_DDM_RDB_Predicates_0500
270 * @tc.desc: napi test RDB Predicates for LessThan
271 * @tc.type: FUNC
272 */
SUB_DDM_RDB_Predicates_0500(napi_env env,napi_callback_info info)273 static napi_value SUB_DDM_RDB_Predicates_0500(napi_env env, napi_callback_info info) {
274 int errCode = 0;
275 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
276 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
277 const char *data5Value = "ABCDEFG";
278 valueObject->putText(valueObject, data5Value);
279 predicates->lessThan(predicates, "data5", valueObject);
280
281 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
282 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
283 int rowCount = 0;
284 errCode = cursor->getRowCount(cursor, &rowCount);
285 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
286
287 valueObject->destroy(valueObject);
288 predicates->destroy(predicates);
289 errCode = cursor->destroy(cursor);
290
291 napi_value returnCode;
292 napi_create_double(env, errCode, &returnCode);
293 return returnCode;
294 }
295 /**
296 * @tc.name: SUB_DDM_RDB_Predicates_0600
297 * @tc.desc: napi test RDB Predicates for LessThanOrEqualTo
298 * @tc.type: FUNC
299 */
SUB_DDM_RDB_Predicates_0600(napi_env env,napi_callback_info info)300 static napi_value SUB_DDM_RDB_Predicates_0600(napi_env env, napi_callback_info info) {
301 int errCode = 0;
302 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
303 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
304 const char *data5Value = "ABCDEFG";
305 valueObject->putText(valueObject, data5Value);
306 predicates->lessThanOrEqualTo(predicates, "data5", valueObject);
307
308 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
309 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
310 int rowCount = 0;
311 errCode = cursor->getRowCount(cursor, &rowCount);
312 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
313
314 valueObject->destroy(valueObject);
315 predicates->destroy(predicates);
316 errCode = cursor->destroy(cursor);
317
318 napi_value returnCode;
319 napi_create_double(env, errCode, &returnCode);
320 return returnCode;
321 }
322 /**
323 * @tc.name: SUB_DDM_RDB_Predicates_0700
324 * @tc.desc: napi test RDB Predicates for IsNull
325 * @tc.type: FUNC
326 */
SUB_DDM_RDB_Predicates_0700(napi_env env,napi_callback_info info)327 static napi_value SUB_DDM_RDB_Predicates_0700(napi_env env, napi_callback_info info) {
328 int errCode = 0;
329 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
330 predicates->isNull(predicates, "data4");
331
332 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
333 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
334 int rowCount = 0;
335 errCode = cursor->getRowCount(cursor, &rowCount);
336 NAPI_ASSERT(env, rowCount == 3, "getRowCount is fail.");
337
338 predicates->destroy(predicates);
339 errCode = cursor->destroy(cursor);
340
341 napi_value returnCode;
342 napi_create_double(env, errCode, &returnCode);
343 return returnCode;
344 }
345 /**
346 * @tc.name: SUB_DDM_RDB_Predicates_0800
347 * @tc.desc: napi test RDB Predicates for isNotNull
348 * @tc.type: FUNC
349 */
SUB_DDM_RDB_Predicates_0800(napi_env env,napi_callback_info info)350 static napi_value SUB_DDM_RDB_Predicates_0800(napi_env env, napi_callback_info info) {
351 int errCode = 0;
352 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
353 predicates->isNotNull(predicates, "data4");
354
355 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
356 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
357 int rowCount = 0;
358 errCode = cursor->getRowCount(cursor, &rowCount);
359 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
360
361 predicates->destroy(predicates);
362 errCode = cursor->destroy(cursor);
363
364 napi_value returnCode;
365 napi_create_double(env, errCode, &returnCode);
366 return returnCode;
367 }
368
369 /**
370 * @tc.name: SUB_DDM_RDB_Predicates_0900
371 * @tc.desc: napi test RDB Predicates for Between
372 * @tc.type: FUNC
373 */
SUB_DDM_RDB_Predicates_0900(napi_env env,napi_callback_info info)374 static napi_value SUB_DDM_RDB_Predicates_0900(napi_env env, napi_callback_info info) {
375 int errCode = 0;
376 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
377 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
378 int64_t data2Value[] = {12000, 13000};
379 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
380 valueObject->putInt64(valueObject, data2Value, len);
381 predicates->between(predicates, "data2", valueObject);
382 double data3Value[] = {0.1, 101.1};
383 len = sizeof(data3Value) / sizeof(data3Value[0]);
384 valueObject->putDouble(valueObject, data3Value, len);
385 predicates->between(predicates, "data3", valueObject);
386
387 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
388 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
389 int rowCount = 0;
390 errCode = cursor->getRowCount(cursor, &rowCount);
391 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
392
393 valueObject->destroy(valueObject);
394 predicates->destroy(predicates);
395 errCode = cursor->destroy(cursor);
396
397 napi_value returnCode;
398 napi_create_double(env, errCode, &returnCode);
399 return returnCode;
400 }
401
402 /**
403 * @tc.name: SUB_DDM_RDB_Predicates_1000
404 * @tc.desc: napi test RDB Predicates for NotBetween
405 * @tc.type: FUNC
406 */
SUB_DDM_RDB_Predicates_1000(napi_env env,napi_callback_info info)407 static napi_value SUB_DDM_RDB_Predicates_1000(napi_env env, napi_callback_info info) {
408 int errCode = 0;
409 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
410 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
411 int64_t data2Value[] = {12000, 13000};
412 int len = sizeof(data2Value) / sizeof(data2Value[0]);
413 valueObject->putInt64(valueObject, data2Value, len);
414 predicates->notBetween(predicates, "data2", valueObject);
415
416 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
417 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
418 int rowCount = 0;
419 errCode = cursor->getRowCount(cursor, &rowCount);
420 NAPI_ASSERT(env, rowCount == 3, "getRowCount is fail.");
421
422 valueObject->destroy(valueObject);
423 predicates->destroy(predicates);
424 errCode = cursor->destroy(cursor);
425
426 napi_value returnCode;
427 napi_create_double(env, errCode, &returnCode);
428 return returnCode;
429 }
430
431
432 /**
433 * @tc.name: SUB_DDM_RDB_Predicates_1100
434 * @tc.desc: napi test RDB Predicates for OrderBy、Limit、Offset.
435 * @tc.type: FUNC
436 */
SUB_DDM_RDB_Predicates_1100(napi_env env,napi_callback_info info)437 static napi_value SUB_DDM_RDB_Predicates_1100(napi_env env, napi_callback_info info) {
438 int errCode = 0;
439 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
440 predicates->orderBy(predicates, "data2", OH_OrderType::ASC);
441 predicates->limit(predicates, 1);
442 predicates->offset(predicates, 0);
443 predicates->distinct(predicates);
444
445 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
446 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
447 int rowCount = 0;
448 errCode = cursor->getRowCount(cursor, &rowCount);
449 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
450
451 errCode = cursor->goToNextRow(cursor);
452 int columnIndex;
453 cursor->getColumnIndex(cursor, "data2", &columnIndex);
454 NAPI_ASSERT(env, columnIndex == 2, "getColumnIndex is fail.");
455
456 int64_t longValue;
457 cursor->getInt64(cursor, columnIndex, &longValue);
458 NAPI_ASSERT(env, longValue == 12800, "getInt64 is fail.");
459
460
461 predicates->destroy(predicates);
462 errCode = cursor->destroy(cursor);
463
464 napi_value returnCode;
465 napi_create_double(env, errCode, &returnCode);
466 return returnCode;
467 }
468
469 /**
470 * @tc.name: SUB_DDM_RDB_Predicates_1200
471 * @tc.desc: napi test RDB Predicates for In.
472 * @tc.type: FUNC
473 */
SUB_DDM_RDB_Predicates_1200(napi_env env,napi_callback_info info)474 static napi_value SUB_DDM_RDB_Predicates_1200(napi_env env, napi_callback_info info) {
475 int errCode = 0;
476 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
477 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
478 const char *data1Value[] = {"zhangSan", "liSi"};
479 int len = sizeof(data1Value) / sizeof(data1Value[0]);
480 valueObject->putTexts(valueObject, data1Value, len);
481 predicates->in(predicates, "data1", valueObject);
482
483 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
484 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
485 int rowCount = 0;
486 errCode = cursor->getRowCount(cursor, &rowCount);
487 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
488
489 valueObject->destroy(valueObject);
490 predicates->destroy(predicates);
491 errCode = cursor->destroy(cursor);
492
493 napi_value returnCode;
494 napi_create_double(env, errCode, &returnCode);
495 return returnCode;
496 }
497
498 /**
499 * @tc.name: SUB_DDM_RDB_Predicates_1300
500 * @tc.desc: napi test RDB Predicates for NotIn
501 * @tc.type: FUNC
502 */
SUB_DDM_RDB_Predicates_1300(napi_env env,napi_callback_info info)503 static napi_value SUB_DDM_RDB_Predicates_1300(napi_env env, napi_callback_info info) {
504 int errCode = 0;
505 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
506 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
507 const char *data1Value[] = {"zhangSan", "liSi"};
508 int len = sizeof(data1Value) / sizeof(data1Value[0]);
509 valueObject->putTexts(valueObject, data1Value, len);
510 predicates->notIn(predicates, "data1", valueObject);
511
512 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
513 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
514 int rowCount = 0;
515 errCode = cursor->getRowCount(cursor, &rowCount);
516 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
517
518 valueObject->destroy(valueObject);
519 predicates->destroy(predicates);
520 errCode = cursor->destroy(cursor);
521
522 napi_value returnCode;
523 napi_create_double(env, errCode, &returnCode);
524 return returnCode;
525 }
526
527 /**
528 * @tc.name: SUB_DDM_RDB_Predicates_1400
529 * @tc.desc: napi test RDB Predicates for Like
530 * @tc.type: FUNC
531 */
SUB_DDM_RDB_Predicates_1400(napi_env env,napi_callback_info info)532 static napi_value SUB_DDM_RDB_Predicates_1400(napi_env env, napi_callback_info info) {
533 int errCode = 0;
534 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
535 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
536 const char *data5Value = "ABCD%";
537 valueObject->putText(valueObject, data5Value);
538 predicates->like(predicates, "data5", valueObject);
539 const char *data2Value = "%800";
540 valueObject->putText(valueObject, data2Value);
541 predicates->like(predicates, "data2", valueObject);
542
543 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
544 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
545 int rowCount = 0;
546 errCode = cursor->getRowCount(cursor, &rowCount);
547 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
548
549 valueObject->destroy(valueObject);
550 predicates->destroy(predicates);
551 errCode = cursor->destroy(cursor);
552
553 napi_value returnCode;
554 napi_create_double(env, errCode, &returnCode);
555 return returnCode;
556 }
557
558 /**
559 * @tc.name: SUB_DDM_RDB_Predicates_1500
560 * @tc.desc: napi test RDB Predicates for GroupBy
561 * @tc.type: FUNC
562 */
SUB_DDM_RDB_Predicates_1500(napi_env env,napi_callback_info info)563 static napi_value SUB_DDM_RDB_Predicates_1500(napi_env env, napi_callback_info info) {
564 int errCode = 0;
565 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
566 const char *columnNames[] = {"data1", "data2"};
567 int len = sizeof(columnNames) / sizeof(columnNames[0]);
568 predicates->groupBy(predicates, columnNames, len);
569
570 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
571 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
572 int rowCount = 0;
573 errCode = cursor->getRowCount(cursor, &rowCount);
574 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
575
576 predicates->destroy(predicates);
577 errCode = cursor->destroy(cursor);
578
579 napi_value returnCode;
580 napi_create_double(env, errCode, &returnCode);
581 return returnCode;
582 }
583 /**
584 * @tc.name: SUB_DDM_RDB_Predicates_1600
585 * @tc.desc: napi test RDB Predicates for And
586 * @tc.type: FUNC
587 */
SUB_DDM_RDB_Predicates_1600(napi_env env,napi_callback_info info)588 static napi_value SUB_DDM_RDB_Predicates_1600(napi_env env, napi_callback_info info) {
589 int errCode = 0;
590 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
591 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
592 const char *data1Value = "zhangSan";
593 valueObject->putText(valueObject, data1Value);
594 predicates->equalTo(predicates, "data1", valueObject);
595 predicates->andOperate(predicates);
596 double data3Value = 100.1;
597 valueObject->putDouble(valueObject, &data3Value, 1);
598 predicates->equalTo(predicates, "data3", valueObject);
599
600 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
601 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
602 int rowCount = 0;
603 errCode = cursor->getRowCount(cursor, &rowCount);
604 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
605
606 valueObject->destroy(valueObject);
607 predicates->destroy(predicates);
608 errCode = cursor->destroy(cursor);
609
610 napi_value returnCode;
611 napi_create_double(env, errCode, &returnCode);
612 return returnCode;
613 }
614 /**
615 * @tc.name: SUB_DDM_RDB_Predicates_1700
616 * @tc.desc: napi test RDB Predicates for Clear
617 * @tc.type: FUNC
618 */
SUB_DDM_RDB_Predicates_1700(napi_env env,napi_callback_info info)619 static napi_value SUB_DDM_RDB_Predicates_1700(napi_env env, napi_callback_info info) {
620 int errCode = 0;
621 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
622 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
623 const char *data1Value = "zhangSan";
624 valueObject->putText(valueObject, data1Value);
625 predicates->equalTo(predicates, "data1", valueObject);
626
627 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
628 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
629 int rowCount = 0;
630 errCode = cursor->getRowCount(cursor, &rowCount);
631 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
632 errCode = cursor->destroy(cursor);
633
634 predicates->clear(predicates);
635 predicates->notEqualTo(predicates, "data1", valueObject);
636 cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
637 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
638 errCode = cursor->getRowCount(cursor, &rowCount);
639 NAPI_ASSERT(env, rowCount == 3, "getRowCount is fail.");
640
641 valueObject->destroy(valueObject);
642 predicates->destroy(predicates);
643 errCode = cursor->destroy(cursor);
644
645 napi_value returnCode;
646 napi_create_double(env, errCode, &returnCode);
647 return returnCode;
648 }
649
650 /**
651 * @tc.name: SUB_DDM_RDB_Predicates_1800
652 * @tc.desc: napi test RDB Predicates for table name is NULL.
653 * @tc.type: FUNC
654 */
SUB_DDM_RDB_Predicates_1800(napi_env env,napi_callback_info info)655 static napi_value SUB_DDM_RDB_Predicates_1800(napi_env env, napi_callback_info info) {
656 char *table = NULL;
657 OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
658 NAPI_ASSERT(env, predicates == NULL, "OH_Rdb_CreatePredicates is fail.");
659
660 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
661 NAPI_ASSERT(env, cursor == NULL, "OH_Rdb_Query is fail.");
662
663 int errCode = 0;
664 napi_value returnCode;
665 napi_create_double(env, errCode, &returnCode);
666 return returnCode;
667 }
668
669 /**
670 * @tc.name: SUB_DDM_RDB_Predicates_1900
671 * @tc.desc: napi test RDB Predicates for equalTo
672 * @tc.type: FUNC
673 */
SUB_DDM_RDB_Predicates_1900(napi_env env,napi_callback_info info)674 static napi_value SUB_DDM_RDB_Predicates_1900(napi_env env, napi_callback_info info) {
675 int errCode = 0;
676 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
677 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
678 const char *data1Value = "zhangSan";
679 valueObject->putText(valueObject, data1Value);
680 predicates->equalTo(predicates, "data1", valueObject);
681
682 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
683 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
684
685 int rowCount = 0;
686 errCode = cursor->getRowCount(cursor, &rowCount);
687 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
688
689 predicates->destroy(predicates);
690 valueObject->destroy(valueObject);
691 errCode = cursor->destroy(cursor);
692
693 napi_value returnCode;
694 napi_create_double(env, errCode, &returnCode);
695 return returnCode;
696 }
697
698 /**
699 * @tc.name: SUB_DDM_RDB_Predicates_2000
700 * @tc.desc: napi test RDB Predicates for equalTo
701 * @tc.type: FUNC
702 */
SUB_DDM_RDB_Predicates_2000(napi_env env,napi_callback_info info)703 static napi_value SUB_DDM_RDB_Predicates_2000(napi_env env, napi_callback_info info) {
704 int errCode = 0;
705 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
706 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
707 uint32_t count = 1;
708 double data3Value = 300.1;
709 valueObject->putDouble(valueObject, &data3Value, count);
710 predicates->equalTo(predicates, "data3", valueObject);
711
712 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
713 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
714
715 int rowCount = 0;
716 errCode = cursor->getRowCount(cursor, &rowCount);
717 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
718
719 predicates->destroy(predicates);
720 valueObject->destroy(valueObject);
721 errCode = cursor->destroy(cursor);
722
723 napi_value returnCode;
724 napi_create_double(env, errCode, &returnCode);
725 return returnCode;
726 }
727
728
729
730 /**
731 * @tc.name: SUB_DDM_RDB_Predicates_2100
732 * @tc.desc: napi test RDB Predicates for equalTo
733 * @tc.type: FUNC
734 */
SUB_DDM_RDB_Predicates_2100(napi_env env,napi_callback_info info)735 static napi_value SUB_DDM_RDB_Predicates_2100(napi_env env, napi_callback_info info) {
736 int errCode = 0;
737 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
738 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
739 uint32_t count = 1;
740 double data3Value = 300.1;
741 valueObject->putDouble(valueObject, &data3Value, count);
742 predicates->equalTo(predicates, "data", valueObject);
743
744 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
745 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
746
747 int rowCount = -1;
748 errCode = cursor->getRowCount(cursor, &rowCount);
749 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
750
751 predicates->destroy(predicates);
752 valueObject->destroy(valueObject);
753 errCode = cursor->destroy(cursor);
754
755 napi_value returnCode;
756 napi_create_double(env, errCode, &returnCode);
757 return returnCode;
758 }
759
760 /**
761 * @tc.name: SUB_DDM_RDB_Predicates_2200
762 * @tc.desc: napi test RDB Predicates for equalTo
763 * @tc.type: FUNC
764 */
SUB_DDM_RDB_Predicates_2200(napi_env env,napi_callback_info info)765 static napi_value SUB_DDM_RDB_Predicates_2200(napi_env env, napi_callback_info info) {
766 int errCode = 0;
767 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
768 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
769 uint32_t count = 1;
770 double data3Value = 1.1;
771 valueObject->putDouble(valueObject, &data3Value, count);
772 predicates->equalTo(predicates, "data3", valueObject);
773
774 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
775 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
776
777 int rowCount = -1;
778 errCode = cursor->getRowCount(cursor, &rowCount);
779 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
780
781 predicates->destroy(predicates);
782 valueObject->destroy(valueObject);
783 errCode = cursor->destroy(cursor);
784
785 napi_value returnCode;
786 napi_create_double(env, errCode, &returnCode);
787 return returnCode;
788 }
789
790 /**
791 * @tc.name: SUB_DDM_RDB_Predicates_2300
792 * @tc.desc: napi test RDB Predicates for notEqualTo
793 * @tc.type: FUNC
794 */
SUB_DDM_RDB_Predicates_2300(napi_env env,napi_callback_info info)795 static napi_value SUB_DDM_RDB_Predicates_2300(napi_env env, napi_callback_info info) {
796 int errCode = 0;
797 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
798 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
799 uint32_t count = 1;
800 double data3Value = 300.1;
801 valueObject->putDouble(valueObject, &data3Value, count);
802 predicates->notEqualTo(predicates, "data3", valueObject);
803
804 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
805 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
806
807 int rowCount = -1;
808 errCode = cursor->getRowCount(cursor, &rowCount);
809 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
810
811 predicates->destroy(predicates);
812 valueObject->destroy(valueObject);
813 errCode = cursor->destroy(cursor);
814
815 napi_value returnCode;
816 napi_create_double(env, errCode, &returnCode);
817 return returnCode;
818 }
819
820 /**
821 * @tc.name: SUB_DDM_RDB_Predicates_2400
822 * @tc.desc: napi test RDB Predicates for notEqualTo
823 * @tc.type: FUNC
824 */
SUB_DDM_RDB_Predicates_2400(napi_env env,napi_callback_info info)825 static napi_value SUB_DDM_RDB_Predicates_2400(napi_env env, napi_callback_info info) {
826 int errCode = 0;
827 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
828 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
829 const char *data1Value = "wangWu";
830 valueObject->putText(valueObject, data1Value);
831 predicates->notEqualTo(predicates, "data1", valueObject);
832 predicates->andOperate(predicates);
833 OH_VObject *valueObject1 = OH_Rdb_CreateValueObject();
834 const char *data1Value1 = "zhangliu";
835 valueObject1->putText(valueObject1, data1Value1);
836 predicates->notEqualTo(predicates, "data1", valueObject1);
837
838 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
839 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
840
841 int rowCount = -1;
842 errCode = cursor->getRowCount(cursor, &rowCount);
843 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
844
845 predicates->destroy(predicates);
846 valueObject->destroy(valueObject);
847 valueObject1->destroy(valueObject1);
848 errCode = cursor->destroy(cursor);
849
850 napi_value returnCode;
851 napi_create_double(env, errCode, &returnCode);
852 return returnCode;
853 }
854
855 /**
856 * @tc.name: SUB_DDM_RDB_Predicates_2500
857 * @tc.desc: napi test RDB Predicates for notEqualTo
858 * @tc.type: FUNC
859 */
SUB_DDM_RDB_Predicates_2500(napi_env env,napi_callback_info info)860 static napi_value SUB_DDM_RDB_Predicates_2500(napi_env env, napi_callback_info info) {
861 int errCode = 0;
862 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
863 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
864 const char *data1Value = "name";
865 valueObject->putText(valueObject, data1Value);
866 predicates->notEqualTo(predicates, "data1", valueObject);
867
868 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
869 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
870
871 int rowCount = -1;
872 errCode = cursor->getRowCount(cursor, &rowCount);
873 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
874
875 predicates->destroy(predicates);
876 valueObject->destroy(valueObject);
877 errCode = cursor->destroy(cursor);
878
879 napi_value returnCode;
880 napi_create_double(env, errCode, &returnCode);
881 return returnCode;
882 }
883
884 /**
885 * @tc.name: SUB_DDM_RDB_Predicates_2600
886 * @tc.desc: napi test RDB Predicates for notEqualTo
887 * @tc.type: FUNC
888 */
SUB_DDM_RDB_Predicates_2600(napi_env env,napi_callback_info info)889 static napi_value SUB_DDM_RDB_Predicates_2600(napi_env env, napi_callback_info info) {
890 int errCode = 0;
891 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
892 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
893 uint32_t count = 1;
894 double data3Value = 300.1;
895 valueObject->putDouble(valueObject, &data3Value, count);
896 predicates->notEqualTo(predicates, "data", valueObject);
897
898 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
899 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
900
901 int rowCount = -1;
902 errCode = cursor->getRowCount(cursor, &rowCount);
903 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
904
905 predicates->destroy(predicates);
906 valueObject->destroy(valueObject);
907 errCode = cursor->destroy(cursor);
908
909 napi_value returnCode;
910 napi_create_double(env, errCode, &returnCode);
911 return returnCode;
912 }
913
914 /**
915 * @tc.name: SUB_DDM_RDB_Predicates_2700
916 * @tc.desc: napi test RDB Predicates for beginWrap and endWrap
917 * @tc.type: FUNC
918 */
SUB_DDM_RDB_Predicates_2700(napi_env env,napi_callback_info info)919 static napi_value SUB_DDM_RDB_Predicates_2700(napi_env env, napi_callback_info info) {
920 int errCode = 0;
921 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
922 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
923 const char *data1Value = "zhangSan";
924 valueObject->putText(valueObject, data1Value);
925 predicates->beginWrap(predicates);
926 predicates->equalTo(predicates, "data1", valueObject);
927 predicates->endWrap(predicates);
928
929 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
930 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
931 int rowCount = 0;
932 errCode = cursor->getRowCount(cursor, &rowCount);
933 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
934
935 predicates->destroy(predicates);
936 valueObject->destroy(valueObject);
937 errCode = cursor->destroy(cursor);
938
939 napi_value returnCode;
940 napi_create_double(env, errCode, &returnCode);
941 return returnCode;
942 }
943
944 /**
945 * @tc.name: SUB_DDM_RDB_Predicates_2800
946 * @tc.desc: napi test RDB Predicates for beginWrap and endWrap
947 * @tc.type: FUNC
948 */
SUB_DDM_RDB_Predicates_2800(napi_env env,napi_callback_info info)949 static napi_value SUB_DDM_RDB_Predicates_2800(napi_env env, napi_callback_info info) {
950 int errCode = 0;
951 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
952 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
953 const char *data1Value = "zhangSan";
954 valueObject->putText(valueObject, data1Value);
955 predicates->equalTo(predicates, "data1", valueObject);
956 predicates->endWrap(predicates);
957
958 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
959 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
960 int rowCount = -1;
961 errCode = cursor->getRowCount(cursor, &rowCount);
962 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
963
964 predicates->destroy(predicates);
965 valueObject->destroy(valueObject);
966 errCode = cursor->destroy(cursor);
967
968 napi_value returnCode;
969 napi_create_double(env, errCode, &returnCode);
970 return returnCode;
971 }
972
973 /**
974 * @tc.name: SUB_DDM_RDB_Predicates_2900
975 * @tc.desc: napi test RDB Predicates for beginWrap and endWrap
976 * @tc.type: FUNC
977 */
SUB_DDM_RDB_Predicates_2900(napi_env env,napi_callback_info info)978 static napi_value SUB_DDM_RDB_Predicates_2900(napi_env env, napi_callback_info info) {
979 int errCode = 0;
980 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
981 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
982 const char *data1Value = "zhangSan";
983 valueObject->putText(valueObject, data1Value);
984 predicates->beginWrap(predicates);
985 predicates->equalTo(predicates, "data1", valueObject);
986
987 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
988 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
989 int rowCount = -1;
990 errCode = cursor->getRowCount(cursor, &rowCount);
991 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
992
993 predicates->destroy(predicates);
994 valueObject->destroy(valueObject);
995 errCode = cursor->destroy(cursor);
996
997 napi_value returnCode;
998 napi_create_double(env, errCode, &returnCode);
999 return returnCode;
1000 }
1001
1002 /**
1003 * @tc.name: SUB_DDM_RDB_Predicates_3000
1004 * @tc.desc: napi test RDB Predicates for EqualTo、AndOR、beginWrap and endWrap
1005 * @tc.type: FUNC
1006 */
SUB_DDM_RDB_Predicates_3000(napi_env env,napi_callback_info info)1007 static napi_value SUB_DDM_RDB_Predicates_3000(napi_env env, napi_callback_info info) {
1008 int errCode = 0;
1009 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1010 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1011 uint32_t count = 1;
1012 const char *data1Value = "zhangSan";
1013 valueObject->putText(valueObject, data1Value);
1014 predicates->beginWrap(predicates);
1015 predicates->equalTo(predicates, "data1", valueObject);
1016 predicates->andOperate(predicates);
1017 double data3Value = 200.1;
1018 valueObject->putDouble(valueObject, &data3Value, count);
1019 predicates->equalTo(predicates, "data3", valueObject);
1020 predicates->endWrap(predicates);
1021
1022 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1023 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1024 int rowCount = -1;
1025 errCode = cursor->getRowCount(cursor, &rowCount);
1026 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1027
1028 predicates->destroy(predicates);
1029 valueObject->destroy(valueObject);
1030 errCode = cursor->destroy(cursor);
1031
1032 napi_value returnCode;
1033 napi_create_double(env, errCode, &returnCode);
1034 return returnCode;
1035 }
1036
1037 /**
1038 * @tc.name: SUB_DDM_RDB_Predicates_3100
1039 * @tc.desc: napi test RDB Predicates for
1040 * @tc.type: FUNC
1041 */
SUB_DDM_RDB_Predicates_3100(napi_env env,napi_callback_info info)1042 static napi_value SUB_DDM_RDB_Predicates_3100(napi_env env, napi_callback_info info) {
1043 int errCode = 0;
1044 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1045 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1046 const char *data1Value = "zhangSan";
1047 valueObject->putText(valueObject, data1Value);
1048 predicates->equalTo(predicates, "data1", valueObject);
1049 predicates->andOperate(predicates);
1050 predicates->orOperate(predicates);
1051 double data3Value = 200.1;
1052 valueObject->putDouble(valueObject, &data3Value, 1);
1053 predicates->equalTo(predicates, "data3", valueObject);
1054
1055 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1056 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1057 int rowCount = -1;
1058 errCode = cursor->getRowCount(cursor, &rowCount);
1059 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1060
1061 predicates->destroy(predicates);
1062 valueObject->destroy(valueObject);
1063 errCode = cursor->destroy(cursor);
1064
1065 napi_value returnCode;
1066 napi_create_double(env, errCode, &returnCode);
1067 return returnCode;
1068 }
1069 /**
1070 * @tc.name: SUB_DDM_RDB_Predicates_3200
1071 * @tc.desc: napi test RDB Predicates for And
1072 * @tc.type: FUNC
1073 */
SUB_DDM_RDB_Predicates_3200(napi_env env,napi_callback_info info)1074 static napi_value SUB_DDM_RDB_Predicates_3200(napi_env env, napi_callback_info info) {
1075 int errCode = 0;
1076 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1077 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1078 const char *data1Value = "zhangSan";
1079 valueObject->putText(valueObject, data1Value);
1080 predicates->equalTo(predicates, "data1", valueObject);
1081 predicates->orOperate(predicates);
1082 predicates->orOperate(predicates);
1083 double data3Value = 200.1;
1084 valueObject->putDouble(valueObject, &data3Value, 1);
1085 predicates->equalTo(predicates, "data3", valueObject);
1086
1087 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1088 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1089 int rowCount = -1;
1090 errCode = cursor->getRowCount(cursor, &rowCount);
1091 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1092
1093 predicates->destroy(predicates);
1094 valueObject->destroy(valueObject);
1095 errCode = cursor->destroy(cursor);
1096
1097 napi_value returnCode;
1098 napi_create_double(env, errCode, &returnCode);
1099 return returnCode;
1100 }
1101
1102 /**
1103 * @tc.name: SUB_DDM_RDB_Predicates_3300
1104 * @tc.desc: napi test RDB Predicates for IsNull
1105 * @tc.type: FUNC
1106 */
SUB_DDM_RDB_Predicates_3300(napi_env env,napi_callback_info info)1107 static napi_value SUB_DDM_RDB_Predicates_3300(napi_env env, napi_callback_info info) {
1108 int errCode = 0;
1109 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1110 predicates->isNull(predicates, "data");
1111
1112 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1113 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1114 int rowCount = -1;
1115 errCode = cursor->getRowCount(cursor, &rowCount);
1116 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1117
1118 predicates->destroy(predicates);
1119 errCode = cursor->destroy(cursor);
1120
1121 napi_value returnCode;
1122 napi_create_double(env, errCode, &returnCode);
1123 return returnCode;
1124 }
1125 /**
1126 * @tc.name: SUB_DDM_RDB_Predicates_3400
1127 * @tc.desc: napi test RDB Predicates for isNotNull
1128 * @tc.type: FUNC
1129 */
SUB_DDM_RDB_Predicates_3400(napi_env env,napi_callback_info info)1130 static napi_value SUB_DDM_RDB_Predicates_3400(napi_env env, napi_callback_info info) {
1131 int errCode = 0;
1132 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1133 predicates->isNotNull(predicates, "data");
1134
1135 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1136 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1137 int rowCount = -1;
1138 errCode = cursor->getRowCount(cursor, &rowCount);
1139 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1140
1141 predicates->destroy(predicates);
1142 errCode = cursor->destroy(cursor);
1143
1144 napi_value returnCode;
1145 napi_create_double(env, errCode, &returnCode);
1146 return returnCode;
1147 }
1148 /**
1149 * @tc.name: SUB_DDM_RDB_Predicates_3500
1150 * @tc.desc: napi test RDB Predicates for Like
1151 * @tc.type: FUNC
1152 */
SUB_DDM_RDB_Predicates_3500(napi_env env,napi_callback_info info)1153 static napi_value SUB_DDM_RDB_Predicates_3500(napi_env env, napi_callback_info info) {
1154 int errCode = 0;
1155 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1156 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1157 const char *data5Value = "%BCD%";
1158 valueObject->putText(valueObject, data5Value);
1159 predicates->like(predicates, "data5", valueObject);
1160
1161 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1162 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1163 int rowCount = 0;
1164 errCode = cursor->getRowCount(cursor, &rowCount);
1165 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
1166
1167 valueObject->destroy(valueObject);
1168 predicates->destroy(predicates);
1169 errCode = cursor->destroy(cursor);
1170
1171 napi_value returnCode;
1172 napi_create_double(env, errCode, &returnCode);
1173 return returnCode;
1174 }
1175 /**
1176 * @tc.name: SUB_DDM_RDB_Predicates_3600
1177 * @tc.desc: napi test RDB Predicates for Like
1178 * @tc.type: FUNC
1179 */
SUB_DDM_RDB_Predicates_3600(napi_env env,napi_callback_info info)1180 static napi_value SUB_DDM_RDB_Predicates_3600(napi_env env, napi_callback_info info) {
1181 int errCode = 0;
1182 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1183 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1184 const char *data5Value = "%BCDx%";
1185 valueObject->putText(valueObject, data5Value);
1186 predicates->like(predicates, "data5", valueObject);
1187
1188 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1189 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1190 int rowCount = -1;
1191 errCode = cursor->getRowCount(cursor, &rowCount);
1192 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1193
1194 valueObject->destroy(valueObject);
1195 predicates->destroy(predicates);
1196 errCode = cursor->destroy(cursor);
1197
1198 napi_value returnCode;
1199 napi_create_double(env, errCode, &returnCode);
1200 return returnCode;
1201 }
1202 /**
1203 * @tc.name: SUB_DDM_RDB_Predicates_3700
1204 * @tc.desc: napi test RDB Predicates for Like
1205 * @tc.type: FUNC
1206 */
SUB_DDM_RDB_Predicates_3700(napi_env env,napi_callback_info info)1207 static napi_value SUB_DDM_RDB_Predicates_3700(napi_env env, napi_callback_info info) {
1208 int errCode = 0;
1209 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1210 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1211 const char *data5Value = "ABCD%";
1212 valueObject->putText(valueObject, data5Value);
1213 predicates->like(predicates, "data", valueObject);
1214
1215 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1216 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1217 int rowCount = 0;
1218 errCode = cursor->getRowCount(cursor, &rowCount);
1219 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1220
1221 valueObject->destroy(valueObject);
1222 predicates->destroy(predicates);
1223 errCode = cursor->destroy(cursor);
1224
1225 napi_value returnCode;
1226 napi_create_double(env, errCode, &returnCode);
1227 return returnCode;
1228 }
1229 /**
1230 * @tc.name: SUB_DDM_RDB_Predicates_3800
1231 * @tc.desc: napi test RDB Predicates for Between
1232 * @tc.type: FUNC
1233 */
SUB_DDM_RDB_Predicates_3800(napi_env env,napi_callback_info info)1234 static napi_value SUB_DDM_RDB_Predicates_3800(napi_env env, napi_callback_info info) {
1235 int errCode = 0;
1236 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1237 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1238 int64_t data2Value[] = {12000, 12000};
1239 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
1240 valueObject->putInt64(valueObject, data2Value, len);
1241 predicates->between(predicates, "data2", valueObject);
1242
1243 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1244 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1245 int rowCount = -1;
1246 errCode = cursor->getRowCount(cursor, &rowCount);
1247 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1248
1249 valueObject->destroy(valueObject);
1250 predicates->destroy(predicates);
1251 errCode = cursor->destroy(cursor);
1252
1253 napi_value returnCode;
1254 napi_create_double(env, errCode, &returnCode);
1255 return returnCode;
1256 }
1257 /**
1258 * @tc.name: SUB_DDM_RDB_Predicates_3900
1259 * @tc.desc: napi test RDB Predicates for Between
1260 * @tc.type: FUNC
1261 */
SUB_DDM_RDB_Predicates_3900(napi_env env,napi_callback_info info)1262 static napi_value SUB_DDM_RDB_Predicates_3900(napi_env env, napi_callback_info info) {
1263 int errCode = 0;
1264 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1265 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1266 int64_t data2Value[] = {13000, 12000};
1267 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
1268 valueObject->putInt64(valueObject, data2Value, len);
1269 predicates->between(predicates, "data2", valueObject);
1270
1271 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1272 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1273 int rowCount = -1;
1274 errCode = cursor->getRowCount(cursor, &rowCount);
1275 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1276
1277 valueObject->destroy(valueObject);
1278 predicates->destroy(predicates);
1279 errCode = cursor->destroy(cursor);
1280
1281 napi_value returnCode;
1282 napi_create_double(env, errCode, &returnCode);
1283 return returnCode;
1284 }
1285 /**
1286 * @tc.name: SUB_DDM_RDB_Predicates_4000
1287 * @tc.desc: napi test RDB Predicates for Between
1288 * @tc.type: FUNC
1289 */
SUB_DDM_RDB_Predicates_4000(napi_env env,napi_callback_info info)1290 static napi_value SUB_DDM_RDB_Predicates_4000(napi_env env, napi_callback_info info) {
1291 int errCode = 0;
1292 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1293 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1294 int64_t data2Value[] = {12000, 13000};
1295 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
1296 valueObject->putInt64(valueObject, data2Value, len);
1297 predicates->between(predicates, "data", valueObject);
1298
1299 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1300 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1301 int rowCount = -1;
1302 errCode = cursor->getRowCount(cursor, &rowCount);
1303 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1304
1305 valueObject->destroy(valueObject);
1306 predicates->destroy(predicates);
1307 errCode = cursor->destroy(cursor);
1308
1309 napi_value returnCode;
1310 napi_create_double(env, errCode, &returnCode);
1311 return returnCode;
1312 }
1313
1314 /**
1315 * @tc.name: SUB_DDM_RDB_Predicates_4100
1316 * @tc.desc: napi test RDB Predicates for NotBetween
1317 * @tc.type: FUNC
1318 */
SUB_DDM_RDB_Predicates_4100(napi_env env,napi_callback_info info)1319 static napi_value SUB_DDM_RDB_Predicates_4100(napi_env env, napi_callback_info info) {
1320 int errCode = 0;
1321 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1322 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1323 int64_t data2Value[] = {12000, 13000};
1324 int len = sizeof(data2Value) / sizeof(data2Value[0]);
1325 valueObject->putInt64(valueObject, data2Value, len);
1326 predicates->notBetween(predicates, "data", valueObject);
1327
1328 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1329 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1330 int rowCount = -1;
1331 errCode = cursor->getRowCount(cursor, &rowCount);
1332 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1333
1334 valueObject->destroy(valueObject);
1335 predicates->destroy(predicates);
1336 errCode = cursor->destroy(cursor);
1337
1338 napi_value returnCode;
1339 napi_create_double(env, errCode, &returnCode);
1340 return returnCode;
1341 }
1342
1343 /**
1344 * @tc.name: SUB_DDM_RDB_Predicates_4200
1345 * @tc.desc: napi test RDB Predicates for GreaterThan
1346 * @tc.type: FUNC
1347 */
SUB_DDM_RDB_Predicates_4200(napi_env env,napi_callback_info info)1348 static napi_value SUB_DDM_RDB_Predicates_4200(napi_env env, napi_callback_info info) {
1349 int errCode = 0;
1350 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1351 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1352 uint32_t count = 1;
1353 double data3Value = 200.1;
1354 valueObject->putDouble(valueObject, &data3Value, count);
1355 predicates->greaterThan(predicates, "data3", valueObject);
1356
1357 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1358 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1359 int rowCount = 0;
1360 errCode = cursor->getRowCount(cursor, &rowCount);
1361 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1362
1363 valueObject->destroy(valueObject);
1364 predicates->destroy(predicates);
1365 errCode = cursor->destroy(cursor);
1366
1367 napi_value returnCode;
1368 napi_create_double(env, errCode, &returnCode);
1369 return returnCode;
1370 }
1371
1372 /**
1373 * @tc.name: SUB_DDM_RDB_Predicates_4300
1374 * @tc.desc: napi test RDB Predicates for GreaterThan
1375 * @tc.type: FUNC
1376 */
SUB_DDM_RDB_Predicates_4300(napi_env env,napi_callback_info info)1377 static napi_value SUB_DDM_RDB_Predicates_4300(napi_env env, napi_callback_info info) {
1378 int errCode = 0;
1379 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1380 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1381 uint32_t count = 1;
1382 double data3Value = 400.1;
1383 valueObject->putDouble(valueObject, &data3Value, count);
1384 predicates->greaterThan(predicates, "data3", valueObject);
1385
1386 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1387 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1388 int rowCount = -1;
1389 errCode = cursor->getRowCount(cursor, &rowCount);
1390 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1391
1392 valueObject->destroy(valueObject);
1393 predicates->destroy(predicates);
1394 errCode = cursor->destroy(cursor);
1395
1396 napi_value returnCode;
1397 napi_create_double(env, errCode, &returnCode);
1398 return returnCode;
1399 }
1400
1401 /**
1402 * @tc.name: SUB_DDM_RDB_Predicates_4400
1403 * @tc.desc: napi test RDB Predicates for GreaterThan
1404 * @tc.type: FUNC
1405 */
SUB_DDM_RDB_Predicates_4400(napi_env env,napi_callback_info info)1406 static napi_value SUB_DDM_RDB_Predicates_4400(napi_env env, napi_callback_info info) {
1407 int errCode = 0;
1408 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1409 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1410 const char *data5Value = "ABCDEFG";
1411 valueObject->putText(valueObject, data5Value);
1412 predicates->greaterThan(predicates, "data", valueObject);
1413
1414 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1415 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1416 int rowCount = -1;
1417 errCode = cursor->getRowCount(cursor, &rowCount);
1418 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1419
1420 valueObject->destroy(valueObject);
1421 predicates->destroy(predicates);
1422 errCode = cursor->destroy(cursor);
1423
1424 napi_value returnCode;
1425 napi_create_double(env, errCode, &returnCode);
1426 return returnCode;
1427 }
1428
1429 /**
1430 * @tc.name: SUB_DDM_RDB_Predicates_4500
1431 * @tc.desc: napi test RDB Predicates for LessThan
1432 * @tc.type: FUNC
1433 */
SUB_DDM_RDB_Predicates_4500(napi_env env,napi_callback_info info)1434 static napi_value SUB_DDM_RDB_Predicates_4500(napi_env env, napi_callback_info info) {
1435 int errCode = 0;
1436 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1437 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1438 const char *data5Value = "ABCDEFG";
1439 valueObject->putText(valueObject, data5Value);
1440 predicates->lessThan(predicates, "data", valueObject);
1441
1442 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1443 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1444 int rowCount = -1;
1445 errCode = cursor->getRowCount(cursor, &rowCount);
1446 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1447
1448 valueObject->destroy(valueObject);
1449 predicates->destroy(predicates);
1450 errCode = cursor->destroy(cursor);
1451
1452 napi_value returnCode;
1453 napi_create_double(env, errCode, &returnCode);
1454 return returnCode;
1455 }
1456
1457 /**
1458 * @tc.name: SUB_DDM_RDB_Predicates_4600
1459 * @tc.desc: napi test RDB Predicates for LessThan
1460 * @tc.type: FUNC
1461 */
SUB_DDM_RDB_Predicates_4600(napi_env env,napi_callback_info info)1462 static napi_value SUB_DDM_RDB_Predicates_4600(napi_env env, napi_callback_info info) {
1463 int errCode = 0;
1464 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1465 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1466 uint32_t count = 1;
1467 double data3Value = 300.1;
1468 valueObject->putDouble(valueObject, &data3Value, count);
1469 predicates->lessThan(predicates, "data3", valueObject);
1470
1471 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1472 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1473 int rowCount = -1;
1474 errCode = cursor->getRowCount(cursor, &rowCount);
1475 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1476
1477 valueObject->destroy(valueObject);
1478 predicates->destroy(predicates);
1479 errCode = cursor->destroy(cursor);
1480
1481 napi_value returnCode;
1482 napi_create_double(env, errCode, &returnCode);
1483 return returnCode;
1484 }
1485
1486 /**
1487 * @tc.name: SUB_DDM_RDB_Predicates_4700
1488 * @tc.desc: napi test RDB Predicates for LessThan
1489 * @tc.type: FUNC
1490 */
SUB_DDM_RDB_Predicates_4700(napi_env env,napi_callback_info info)1491 static napi_value SUB_DDM_RDB_Predicates_4700(napi_env env, napi_callback_info info) {
1492 int errCode = 0;
1493 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1494 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1495 uint32_t count = 1;
1496 double data3Value = 10.1;
1497 valueObject->putDouble(valueObject, &data3Value, count);
1498 predicates->lessThan(predicates, "data3", valueObject);
1499
1500 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1501 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1502 int rowCount = -1;
1503 errCode = cursor->getRowCount(cursor, &rowCount);
1504 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1505
1506 valueObject->destroy(valueObject);
1507 predicates->destroy(predicates);
1508 errCode = cursor->destroy(cursor);
1509
1510 napi_value returnCode;
1511 napi_create_double(env, errCode, &returnCode);
1512 return returnCode;
1513 }
1514
1515 /**
1516 * @tc.name: SUB_DDM_RDB_Predicates_4800
1517 * @tc.desc: napi test RDB Predicates for GreaterThanOrEqualTo
1518 * @tc.type: FUNC
1519 */
SUB_DDM_RDB_Predicates_4800(napi_env env,napi_callback_info info)1520 static napi_value SUB_DDM_RDB_Predicates_4800(napi_env env, napi_callback_info info) {
1521 int errCode = 0;
1522 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1523 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1524 const char *data5Value = "ABCDEFG";
1525 valueObject->putText(valueObject, data5Value);
1526 predicates->greaterThanOrEqualTo(predicates, "data", valueObject);
1527
1528 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1529 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1530 int rowCount = -1;
1531 errCode = cursor->getRowCount(cursor, &rowCount);
1532 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1533
1534 valueObject->destroy(valueObject);
1535 predicates->destroy(predicates);
1536 errCode = cursor->destroy(cursor);
1537
1538 napi_value returnCode;
1539 napi_create_double(env, errCode, &returnCode);
1540 return returnCode;
1541 }
1542
1543 /**
1544 * @tc.name: SUB_DDM_RDB_Predicates_4900
1545 * @tc.desc: napi test RDB Predicates for GreaterThanOrEqualTo
1546 * @tc.type: FUNC
1547 */
SUB_DDM_RDB_Predicates_4900(napi_env env,napi_callback_info info)1548 static napi_value SUB_DDM_RDB_Predicates_4900(napi_env env, napi_callback_info info) {
1549 int errCode = 0;
1550 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1551 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1552 uint32_t count = 1;
1553 double data3Value = 300.1;
1554 valueObject->putDouble(valueObject, &data3Value, count);
1555 predicates->greaterThanOrEqualTo(predicates, "data3", valueObject);
1556
1557 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1558 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1559 int rowCount = 0;
1560 errCode = cursor->getRowCount(cursor, &rowCount);
1561 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1562
1563 valueObject->destroy(valueObject);
1564 predicates->destroy(predicates);
1565 errCode = cursor->destroy(cursor);
1566
1567 napi_value returnCode;
1568 napi_create_double(env, errCode, &returnCode);
1569 return returnCode;
1570 }
1571 /**
1572 * @tc.name: SUB_DDM_RDB_Predicates_5000
1573 * @tc.desc: napi test RDB Predicates for GreaterThanOrEqualTo
1574 * @tc.type: FUNC
1575 */
SUB_DDM_RDB_Predicates_5000(napi_env env,napi_callback_info info)1576 static napi_value SUB_DDM_RDB_Predicates_5000(napi_env env, napi_callback_info info) {
1577 int errCode = 0;
1578 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1579 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1580 uint32_t count = 1;
1581 double data3Value = 400.1;
1582 valueObject->putDouble(valueObject, &data3Value, count);
1583 predicates->greaterThanOrEqualTo(predicates, "data3", valueObject);
1584
1585 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1586 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1587 int rowCount = -1;
1588 errCode = cursor->getRowCount(cursor, &rowCount);
1589 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1590
1591 valueObject->destroy(valueObject);
1592 predicates->destroy(predicates);
1593 errCode = cursor->destroy(cursor);
1594
1595 napi_value returnCode;
1596 napi_create_double(env, errCode, &returnCode);
1597 return returnCode;
1598 }
1599
1600 /**
1601 * @tc.name: SUB_DDM_RDB_Predicates_5100
1602 * @tc.desc: napi test RDB Predicates for LessThanOrEqualTo
1603 * @tc.type: FUNC
1604 */
SUB_DDM_RDB_Predicates_5100(napi_env env,napi_callback_info info)1605 static napi_value SUB_DDM_RDB_Predicates_5100(napi_env env, napi_callback_info info) {
1606 int errCode = 0;
1607 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1608 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1609 const char *data5Value = "ABCDEFG";
1610 valueObject->putText(valueObject, data5Value);
1611 predicates->lessThanOrEqualTo(predicates, "data", valueObject);
1612
1613 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1614 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1615 int rowCount = -1;
1616 errCode = cursor->getRowCount(cursor, &rowCount);
1617 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1618
1619 valueObject->destroy(valueObject);
1620 predicates->destroy(predicates);
1621 errCode = cursor->destroy(cursor);
1622
1623 napi_value returnCode;
1624 napi_create_double(env, errCode, &returnCode);
1625 return returnCode;
1626 }
1627
1628 /**
1629 * @tc.name: SUB_DDM_RDB_Predicates_5200
1630 * @tc.desc: napi test RDB Predicates for LessThanOrEqualTo
1631 * @tc.type: FUNC
1632 */
SUB_DDM_RDB_Predicates_5200(napi_env env,napi_callback_info info)1633 static napi_value SUB_DDM_RDB_Predicates_5200(napi_env env, napi_callback_info info) {
1634 int errCode = 0;
1635 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1636 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1637 uint32_t count = 1;
1638 double data3Value = 1.1;
1639 valueObject->putDouble(valueObject, &data3Value, count);
1640 predicates->lessThanOrEqualTo(predicates, "data3", valueObject);
1641
1642 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1643 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1644 int rowCount = -1;
1645 errCode = cursor->getRowCount(cursor, &rowCount);
1646 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
1647
1648 valueObject->destroy(valueObject);
1649 predicates->destroy(predicates);
1650 errCode = cursor->destroy(cursor);
1651
1652 napi_value returnCode;
1653 napi_create_double(env, errCode, &returnCode);
1654 return returnCode;
1655 }
1656 /**
1657 * @tc.name: SUB_DDM_RDB_Predicates_5300
1658 * @tc.desc: napi test RDB Predicates for
1659 * @tc.type: FUNC
1660 */
SUB_DDM_RDB_Predicates_5300(napi_env env,napi_callback_info info)1661 static napi_value SUB_DDM_RDB_Predicates_5300(napi_env env, napi_callback_info info) {
1662 int errCode = 0;
1663 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1664 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1665 uint32_t count = 1;
1666 double data3Value = 200.1;
1667 valueObject->putDouble(valueObject, &data3Value, count);
1668 predicates->lessThanOrEqualTo(predicates, "data3", valueObject);
1669
1670 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1671 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1672 int rowCount = 0;
1673 errCode = cursor->getRowCount(cursor, &rowCount);
1674 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1675
1676 valueObject->destroy(valueObject);
1677 predicates->destroy(predicates);
1678 errCode = cursor->destroy(cursor);
1679
1680 napi_value returnCode;
1681 napi_create_double(env, errCode, &returnCode);
1682 return returnCode;
1683 }
1684 /**
1685 * @tc.name: SUB_DDM_RDB_Predicates_5400
1686 * @tc.desc: napi test RDB Predicates for GroupBy
1687 * @tc.type: FUNC
1688 */
SUB_DDM_RDB_Predicates_5400(napi_env env,napi_callback_info info)1689 static napi_value SUB_DDM_RDB_Predicates_5400(napi_env env, napi_callback_info info) {
1690 int errCode = 0;
1691 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1692 const char *columnNames[] = {"data", "data2"};
1693 int len = sizeof(columnNames) / sizeof(columnNames[0]);
1694 predicates->groupBy(predicates, columnNames, len);
1695
1696 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1697 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1698 int rowCount = -1;
1699 errCode = cursor->getRowCount(cursor, &rowCount);
1700 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1701
1702 predicates->destroy(predicates);
1703 errCode = cursor->destroy(cursor);
1704
1705 napi_value returnCode;
1706 napi_create_double(env, errCode, &returnCode);
1707 return returnCode;
1708 }
1709 /**
1710 * @tc.name: SUB_DDM_RDB_Predicates_5500
1711 * @tc.desc: napi test RDB Predicates for GroupBy
1712 * @tc.type: FUNC
1713 */
SUB_DDM_RDB_Predicates_5500(napi_env env,napi_callback_info info)1714 static napi_value SUB_DDM_RDB_Predicates_5500(napi_env env, napi_callback_info info) {
1715 int errCode = 0;
1716 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1717 const char *columnNames[] = {"data1", "data2"};
1718 predicates->groupBy(predicates, columnNames, 0);
1719
1720 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1721 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1722 int rowCount = -1;
1723 errCode = cursor->getRowCount(cursor, &rowCount);
1724 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
1725
1726 predicates->destroy(predicates);
1727 errCode = cursor->destroy(cursor);
1728
1729 napi_value returnCode;
1730 napi_create_double(env, errCode, &returnCode);
1731 return returnCode;
1732 }
1733 /**
1734 * @tc.name: SUB_DDM_RDB_Predicates_5600
1735 * @tc.desc: napi test RDB Predicates for GroupBy
1736 * @tc.type: FUNC
1737 */
SUB_DDM_RDB_Predicates_5600(napi_env env,napi_callback_info info)1738 static napi_value SUB_DDM_RDB_Predicates_5600(napi_env env, napi_callback_info info) {
1739 int errCode = 0;
1740 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1741 const char *columnNames[] = {"data1", "data2"};
1742 predicates->groupBy(predicates, columnNames, 2);
1743
1744 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1745 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1746 int rowCount = -1;
1747 errCode = cursor->getRowCount(cursor, &rowCount);
1748 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
1749
1750 predicates->destroy(predicates);
1751 errCode = cursor->destroy(cursor);
1752
1753 napi_value returnCode;
1754 napi_create_double(env, errCode, &returnCode);
1755 return returnCode;
1756 }
1757
1758 /**
1759 * @tc.name: SUB_DDM_RDB_Predicates_5800
1760 * @tc.desc: napi test RDB Predicates for GroupBy
1761 * @tc.type: FUNC
1762 */
SUB_DDM_RDB_Predicates_5800(napi_env env,napi_callback_info info)1763 static napi_value SUB_DDM_RDB_Predicates_5800(napi_env env, napi_callback_info info) {
1764 int errCode = 0;
1765 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1766 const char *columnNames[] = {"data2", "data3"};
1767 predicates->groupBy(predicates, columnNames, 1);
1768
1769 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1770 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1771 int rowCount = -1;
1772 errCode = cursor->getRowCount(cursor, &rowCount);
1773 NAPI_ASSERT(env, rowCount == 3, "getRowCount is fail.");
1774
1775 predicates->destroy(predicates);
1776 errCode = cursor->destroy(cursor);
1777
1778 napi_value returnCode;
1779 napi_create_double(env, errCode, &returnCode);
1780 return returnCode;
1781 }
1782 /**
1783 * @tc.name: SUB_DDM_RDB_Predicates_5900
1784 * @tc.desc: napi test RDB Predicates for In.
1785 * @tc.type: FUNC
1786 */
SUB_DDM_RDB_Predicates_5900(napi_env env,napi_callback_info info)1787 static napi_value SUB_DDM_RDB_Predicates_5900(napi_env env, napi_callback_info info) {
1788 int errCode = 0;
1789 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1790 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1791 const char *data1Value[] = {"zhangSan", "liSi"};
1792 int len = sizeof(data1Value) / sizeof(data1Value[0]);
1793 valueObject->putTexts(valueObject, data1Value, len);
1794 predicates->in(predicates, "data", valueObject);
1795
1796 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1797 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1798 int rowCount = -1;
1799 errCode = cursor->getRowCount(cursor, &rowCount);
1800 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1801
1802 valueObject->destroy(valueObject);
1803 predicates->destroy(predicates);
1804 errCode = cursor->destroy(cursor);
1805
1806 napi_value returnCode;
1807 napi_create_double(env, errCode, &returnCode);
1808 return returnCode;
1809 }
1810 /**
1811 * @tc.name: SUB_DDM_RDB_Predicates_6000
1812 * @tc.desc: napi test RDB Predicates for In.
1813 * @tc.type: FUNC
1814 */
SUB_DDM_RDB_Predicates_6000(napi_env env,napi_callback_info info)1815 static napi_value SUB_DDM_RDB_Predicates_6000(napi_env env, napi_callback_info info) {
1816 int errCode = 0;
1817 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1818 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1819 int64_t data2Value[] = {12800, 13000};
1820 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
1821 valueObject->putInt64(valueObject, data2Value, len);
1822 predicates->in(predicates, "data2", valueObject);
1823
1824 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1825 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1826 int rowCount = -1;
1827 errCode = cursor->getRowCount(cursor, &rowCount);
1828 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1829
1830 valueObject->destroy(valueObject);
1831 predicates->destroy(predicates);
1832 errCode = cursor->destroy(cursor);
1833
1834 napi_value returnCode;
1835 napi_create_double(env, errCode, &returnCode);
1836 return returnCode;
1837 }
1838
1839 /**
1840 * @tc.name: SUB_DDM_RDB_Predicates_6100
1841 * @tc.desc: napi test RDB Predicates for NotIn
1842 * @tc.type: FUNC
1843 */
SUB_DDM_RDB_Predicates_6100(napi_env env,napi_callback_info info)1844 static napi_value SUB_DDM_RDB_Predicates_6100(napi_env env, napi_callback_info info) {
1845 int errCode = 0;
1846 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1847 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1848 const char *data1Value[] = {"zhangSan", "liSi"};
1849 int len = sizeof(data1Value) / sizeof(data1Value[0]);
1850 valueObject->putTexts(valueObject, data1Value, len);
1851 predicates->notIn(predicates, "data", valueObject);
1852
1853 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1854 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1855 int rowCount = -1;
1856 errCode = cursor->getRowCount(cursor, &rowCount);
1857 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1858
1859 valueObject->destroy(valueObject);
1860 predicates->destroy(predicates);
1861 errCode = cursor->destroy(cursor);
1862
1863 napi_value returnCode;
1864 napi_create_double(env, errCode, &returnCode);
1865 return returnCode;
1866 }
1867
1868 /**
1869 * @tc.name: SUB_DDM_RDB_Predicates_6200
1870 * @tc.desc: napi test RDB Predicates for NotIn
1871 * @tc.type: FUNC
1872 */
SUB_DDM_RDB_Predicates_6200(napi_env env,napi_callback_info info)1873 static napi_value SUB_DDM_RDB_Predicates_6200(napi_env env, napi_callback_info info) {
1874 int errCode = 0;
1875 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1876 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1877 int64_t data2Value[] = {12800, 13800};
1878 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
1879 valueObject->putInt64(valueObject, data2Value, len);
1880 predicates->notIn(predicates, "data2", valueObject);
1881
1882 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1883 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1884 int rowCount = -1;
1885 errCode = cursor->getRowCount(cursor, &rowCount);
1886 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1887
1888 valueObject->destroy(valueObject);
1889 predicates->destroy(predicates);
1890 errCode = cursor->destroy(cursor);
1891
1892 napi_value returnCode;
1893 napi_create_double(env, errCode, &returnCode);
1894 return returnCode;
1895 }
1896 /**
1897 * @tc.name: SUB_DDM_RDB_Predicates_6300
1898 * @tc.desc: napi test RDB Predicates for OrderBy
1899 * @tc.type: FUNC
1900 */
SUB_DDM_RDB_Predicates_6300(napi_env env,napi_callback_info info)1901 static napi_value SUB_DDM_RDB_Predicates_6300(napi_env env, napi_callback_info info) {
1902 int errCode = 0;
1903 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1904 predicates->orderBy(predicates, "data2", OH_OrderType::DESC);
1905 predicates->limit(predicates, 1);
1906 predicates->offset(predicates, 0);
1907 predicates->distinct(predicates);
1908
1909 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1910 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1911 int rowCount = 0;
1912 errCode = cursor->getRowCount(cursor, &rowCount);
1913 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1914
1915 errCode = cursor->goToNextRow(cursor);
1916 int columnIndex;
1917 cursor->getColumnIndex(cursor, "data2", &columnIndex);
1918 NAPI_ASSERT(env, columnIndex == 2, "getColumnIndex is fail.");
1919
1920 int64_t longValue;
1921 cursor->getInt64(cursor, columnIndex, &longValue);
1922 NAPI_ASSERT(env, longValue == 14800, "getInt64 is fail.");
1923
1924 predicates->destroy(predicates);
1925 errCode = cursor->destroy(cursor);
1926
1927 napi_value returnCode;
1928 napi_create_double(env, errCode, &returnCode);
1929 return returnCode;
1930 }
1931 /**
1932 * @tc.name: SUB_DDM_RDB_Predicates_6400
1933 * @tc.desc: napi test RDB Predicates for OrderBy
1934 * @tc.type: FUNC
1935 */
SUB_DDM_RDB_Predicates_6400(napi_env env,napi_callback_info info)1936 static napi_value SUB_DDM_RDB_Predicates_6400(napi_env env, napi_callback_info info) {
1937 int errCode = 0;
1938 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1939 predicates->orderBy(predicates, "data", OH_OrderType::ASC);
1940 predicates->limit(predicates, 1);
1941 predicates->offset(predicates, 0);
1942 predicates->distinct(predicates);
1943
1944 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1945 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1946 int rowCount = -1;
1947 errCode = cursor->getRowCount(cursor, &rowCount);
1948 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
1949
1950 predicates->destroy(predicates);
1951 errCode = cursor->destroy(cursor);
1952
1953 napi_value returnCode;
1954 napi_create_double(env, errCode, &returnCode);
1955 return returnCode;
1956 }
1957 /**
1958 * @tc.name: SUB_DDM_RDB_Predicates_6500
1959 * @tc.desc: napi test RDB Predicates for Limit
1960 * @tc.type: FUNC
1961 */
SUB_DDM_RDB_Predicates_6500(napi_env env,napi_callback_info info)1962 static napi_value SUB_DDM_RDB_Predicates_6500(napi_env env, napi_callback_info info) {
1963 int errCode = 0;
1964 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1965 predicates->orderBy(predicates, "data2", OH_OrderType::ASC);
1966 predicates->limit(predicates, 0);
1967 predicates->offset(predicates, 0);
1968 predicates->distinct(predicates);
1969
1970 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1971 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1972 int rowCount = -1;
1973 errCode = cursor->getRowCount(cursor, &rowCount);
1974 NAPI_ASSERT(env, rowCount == 4, "getRowCount is fail.");
1975
1976 predicates->destroy(predicates);
1977 errCode = cursor->destroy(cursor);
1978
1979 napi_value returnCode;
1980 napi_create_double(env, errCode, &returnCode);
1981 return returnCode;
1982 }
1983
1984 /**
1985 * @tc.name: SUB_DDM_RDB_Predicates_6600
1986 * @tc.desc: napi test RDB Predicates for Offset
1987 * @tc.type: FUNC
1988 */
SUB_DDM_RDB_Predicates_6600(napi_env env,napi_callback_info info)1989 static napi_value SUB_DDM_RDB_Predicates_6600(napi_env env, napi_callback_info info) {
1990 int errCode = 0;
1991 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1992 predicates->orderBy(predicates, "data2", OH_OrderType::ASC);
1993 predicates->limit(predicates, 1);
1994 predicates->offset(predicates, 5);
1995 predicates->distinct(predicates);
1996
1997 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1998 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1999 int rowCount = -1;
2000 errCode = cursor->getRowCount(cursor, &rowCount);
2001 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
2002
2003 predicates->destroy(predicates);
2004 errCode = cursor->destroy(cursor);
2005
2006 napi_value returnCode;
2007 napi_create_double(env, errCode, &returnCode);
2008 return returnCode;
2009 }
2010
2011 /**
2012 * @tc.name: SUB_DDM_RDB_Predicates_6700
2013 * @tc.desc: napi test RDB Predicates for Offset
2014 * @tc.type: FUNC
2015 */
SUB_DDM_RDB_Predicates_6700(napi_env env,napi_callback_info info)2016 static napi_value SUB_DDM_RDB_Predicates_6700(napi_env env, napi_callback_info info) {
2017 int errCode = 0;
2018 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
2019 predicates->orderBy(predicates, "data2", OH_OrderType::ASC);
2020 predicates->limit(predicates, 1);
2021 predicates->offset(predicates, -1);
2022 predicates->distinct(predicates);
2023
2024 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
2025 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
2026 int rowCount = -1;
2027 errCode = cursor->getRowCount(cursor, &rowCount);
2028 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
2029
2030 predicates->destroy(predicates);
2031 errCode = cursor->destroy(cursor);
2032
2033 napi_value returnCode;
2034 napi_create_double(env, errCode, &returnCode);
2035 return returnCode;
2036 }
2037
2038 EXTERN_C_START
Init(napi_env env,napi_value exports)2039 static napi_value Init(napi_env env, napi_value exports) {
2040 napi_property_descriptor desc[] = {
2041 {"RdbFilePath", nullptr, RdbFilePath, nullptr, nullptr, nullptr, napi_default, nullptr},
2042 {"PredicatesSetUpTestCase", nullptr, PredicatesSetUpTestCase, nullptr, nullptr, nullptr, napi_default, nullptr},
2043 {"PredicatesTearDownTestCase", nullptr, PredicatesTearDownTestCase, nullptr, nullptr, nullptr, napi_default, nullptr},
2044 {"SUB_DDM_RDB_Predicates_0100", nullptr, SUB_DDM_RDB_Predicates_0100, nullptr, nullptr, nullptr, napi_default, nullptr},
2045 {"SUB_DDM_RDB_Predicates_0200", nullptr, SUB_DDM_RDB_Predicates_0200, nullptr, nullptr, nullptr, napi_default, nullptr},
2046 {"SUB_DDM_RDB_Predicates_0300", nullptr, SUB_DDM_RDB_Predicates_0300, nullptr, nullptr, nullptr, napi_default, nullptr},
2047 {"SUB_DDM_RDB_Predicates_0400", nullptr, SUB_DDM_RDB_Predicates_0400, nullptr, nullptr, nullptr, napi_default, nullptr},
2048 {"SUB_DDM_RDB_Predicates_0500", nullptr, SUB_DDM_RDB_Predicates_0500, nullptr, nullptr, nullptr, napi_default, nullptr},
2049 {"SUB_DDM_RDB_Predicates_0600", nullptr, SUB_DDM_RDB_Predicates_0600, nullptr, nullptr, nullptr, napi_default, nullptr},
2050 {"SUB_DDM_RDB_Predicates_0700", nullptr, SUB_DDM_RDB_Predicates_0700, nullptr, nullptr, nullptr, napi_default, nullptr},
2051 {"SUB_DDM_RDB_Predicates_0800", nullptr, SUB_DDM_RDB_Predicates_0800, nullptr, nullptr, nullptr, napi_default, nullptr},
2052 {"SUB_DDM_RDB_Predicates_0900", nullptr, SUB_DDM_RDB_Predicates_0900, nullptr, nullptr, nullptr, napi_default, nullptr},
2053 {"SUB_DDM_RDB_Predicates_1000", nullptr, SUB_DDM_RDB_Predicates_1000, nullptr, nullptr, nullptr, napi_default, nullptr},
2054 {"SUB_DDM_RDB_Predicates_1100", nullptr, SUB_DDM_RDB_Predicates_1100, nullptr, nullptr, nullptr, napi_default, nullptr},
2055 {"SUB_DDM_RDB_Predicates_1200", nullptr, SUB_DDM_RDB_Predicates_1200, nullptr, nullptr, nullptr, napi_default, nullptr},
2056 {"SUB_DDM_RDB_Predicates_1300", nullptr, SUB_DDM_RDB_Predicates_1300, nullptr, nullptr, nullptr, napi_default, nullptr},
2057 {"SUB_DDM_RDB_Predicates_1400", nullptr, SUB_DDM_RDB_Predicates_1400, nullptr, nullptr, nullptr, napi_default, nullptr},
2058 {"SUB_DDM_RDB_Predicates_1500", nullptr, SUB_DDM_RDB_Predicates_1500, nullptr, nullptr, nullptr, napi_default, nullptr},
2059 {"SUB_DDM_RDB_Predicates_1600", nullptr, SUB_DDM_RDB_Predicates_1600, nullptr, nullptr, nullptr, napi_default, nullptr},
2060 {"SUB_DDM_RDB_Predicates_1700", nullptr, SUB_DDM_RDB_Predicates_1700, nullptr, nullptr, nullptr, napi_default, nullptr},
2061 {"SUB_DDM_RDB_Predicates_1800", nullptr, SUB_DDM_RDB_Predicates_1800, nullptr, nullptr, nullptr, napi_default, nullptr},
2062 {"SUB_DDM_RDB_Predicates_1900", nullptr, SUB_DDM_RDB_Predicates_1900, nullptr, nullptr, nullptr, napi_default, nullptr},
2063 {"SUB_DDM_RDB_Predicates_2000", nullptr, SUB_DDM_RDB_Predicates_2000, nullptr, nullptr, nullptr, napi_default, nullptr},
2064 {"SUB_DDM_RDB_Predicates_2100", nullptr, SUB_DDM_RDB_Predicates_2100, nullptr, nullptr, nullptr, napi_default, nullptr},
2065 {"SUB_DDM_RDB_Predicates_2200", nullptr, SUB_DDM_RDB_Predicates_2200, nullptr, nullptr, nullptr, napi_default, nullptr},
2066 {"SUB_DDM_RDB_Predicates_2300", nullptr, SUB_DDM_RDB_Predicates_2300, nullptr, nullptr, nullptr, napi_default, nullptr},
2067 {"SUB_DDM_RDB_Predicates_2400", nullptr, SUB_DDM_RDB_Predicates_2400, nullptr, nullptr, nullptr, napi_default, nullptr},
2068 {"SUB_DDM_RDB_Predicates_2500", nullptr, SUB_DDM_RDB_Predicates_2500, nullptr, nullptr, nullptr, napi_default, nullptr},
2069 {"SUB_DDM_RDB_Predicates_2600", nullptr, SUB_DDM_RDB_Predicates_2600, nullptr, nullptr, nullptr, napi_default, nullptr},
2070 {"SUB_DDM_RDB_Predicates_2700", nullptr, SUB_DDM_RDB_Predicates_2700, nullptr, nullptr, nullptr, napi_default, nullptr},
2071 {"SUB_DDM_RDB_Predicates_2800", nullptr, SUB_DDM_RDB_Predicates_2800, nullptr, nullptr, nullptr, napi_default, nullptr},
2072 {"SUB_DDM_RDB_Predicates_2900", nullptr, SUB_DDM_RDB_Predicates_2900, nullptr, nullptr, nullptr, napi_default, nullptr},
2073 {"SUB_DDM_RDB_Predicates_3000", nullptr, SUB_DDM_RDB_Predicates_3000, nullptr, nullptr, nullptr, napi_default, nullptr},
2074 {"SUB_DDM_RDB_Predicates_3100", nullptr, SUB_DDM_RDB_Predicates_3100, nullptr, nullptr, nullptr, napi_default, nullptr},
2075 {"SUB_DDM_RDB_Predicates_3200", nullptr, SUB_DDM_RDB_Predicates_3200, nullptr, nullptr, nullptr, napi_default, nullptr},
2076 {"SUB_DDM_RDB_Predicates_3300", nullptr, SUB_DDM_RDB_Predicates_3300, nullptr, nullptr, nullptr, napi_default, nullptr},
2077 {"SUB_DDM_RDB_Predicates_3400", nullptr, SUB_DDM_RDB_Predicates_3400, nullptr, nullptr, nullptr, napi_default, nullptr},
2078 {"SUB_DDM_RDB_Predicates_3500", nullptr, SUB_DDM_RDB_Predicates_3500, nullptr, nullptr, nullptr, napi_default, nullptr},
2079 {"SUB_DDM_RDB_Predicates_3600", nullptr, SUB_DDM_RDB_Predicates_3600, nullptr, nullptr, nullptr, napi_default, nullptr},
2080 {"SUB_DDM_RDB_Predicates_3700", nullptr, SUB_DDM_RDB_Predicates_3700, nullptr, nullptr, nullptr, napi_default, nullptr},
2081 {"SUB_DDM_RDB_Predicates_3800", nullptr, SUB_DDM_RDB_Predicates_3800, nullptr, nullptr, nullptr, napi_default, nullptr},
2082 {"SUB_DDM_RDB_Predicates_3900", nullptr, SUB_DDM_RDB_Predicates_3900, nullptr, nullptr, nullptr, napi_default, nullptr},
2083 {"SUB_DDM_RDB_Predicates_4000", nullptr, SUB_DDM_RDB_Predicates_4000, nullptr, nullptr, nullptr, napi_default, nullptr},
2084 {"SUB_DDM_RDB_Predicates_4100", nullptr, SUB_DDM_RDB_Predicates_4100, nullptr, nullptr, nullptr, napi_default, nullptr},
2085 {"SUB_DDM_RDB_Predicates_4200", nullptr, SUB_DDM_RDB_Predicates_4200, nullptr, nullptr, nullptr, napi_default, nullptr},
2086 {"SUB_DDM_RDB_Predicates_4300", nullptr, SUB_DDM_RDB_Predicates_4300, nullptr, nullptr, nullptr, napi_default, nullptr},
2087 {"SUB_DDM_RDB_Predicates_4400", nullptr, SUB_DDM_RDB_Predicates_4400, nullptr, nullptr, nullptr, napi_default, nullptr},
2088 {"SUB_DDM_RDB_Predicates_4500", nullptr, SUB_DDM_RDB_Predicates_4500, nullptr, nullptr, nullptr, napi_default, nullptr},
2089 {"SUB_DDM_RDB_Predicates_4600", nullptr, SUB_DDM_RDB_Predicates_4600, nullptr, nullptr, nullptr, napi_default, nullptr},
2090 {"SUB_DDM_RDB_Predicates_4700", nullptr, SUB_DDM_RDB_Predicates_4700, nullptr, nullptr, nullptr, napi_default, nullptr},
2091 {"SUB_DDM_RDB_Predicates_4800", nullptr, SUB_DDM_RDB_Predicates_4800, nullptr, nullptr, nullptr, napi_default, nullptr},
2092 {"SUB_DDM_RDB_Predicates_4900", nullptr, SUB_DDM_RDB_Predicates_4900, nullptr, nullptr, nullptr, napi_default, nullptr},
2093 {"SUB_DDM_RDB_Predicates_5000", nullptr, SUB_DDM_RDB_Predicates_5000, nullptr, nullptr, nullptr, napi_default, nullptr},
2094 {"SUB_DDM_RDB_Predicates_5100", nullptr, SUB_DDM_RDB_Predicates_5100, nullptr, nullptr, nullptr, napi_default, nullptr},
2095 {"SUB_DDM_RDB_Predicates_5200", nullptr, SUB_DDM_RDB_Predicates_5200, nullptr, nullptr, nullptr, napi_default, nullptr},
2096 {"SUB_DDM_RDB_Predicates_5300", nullptr, SUB_DDM_RDB_Predicates_5300, nullptr, nullptr, nullptr, napi_default, nullptr},
2097 {"SUB_DDM_RDB_Predicates_5400", nullptr, SUB_DDM_RDB_Predicates_5400, nullptr, nullptr, nullptr, napi_default, nullptr},
2098 {"SUB_DDM_RDB_Predicates_5500", nullptr, SUB_DDM_RDB_Predicates_5500, nullptr, nullptr, nullptr, napi_default, nullptr},
2099 {"SUB_DDM_RDB_Predicates_5600", nullptr, SUB_DDM_RDB_Predicates_5600, nullptr, nullptr, nullptr, napi_default, nullptr},
2100 {"SUB_DDM_RDB_Predicates_5800", nullptr, SUB_DDM_RDB_Predicates_5800, nullptr, nullptr, nullptr, napi_default, nullptr},
2101 {"SUB_DDM_RDB_Predicates_5900", nullptr, SUB_DDM_RDB_Predicates_5900, nullptr, nullptr, nullptr, napi_default, nullptr},
2102 {"SUB_DDM_RDB_Predicates_6000", nullptr, SUB_DDM_RDB_Predicates_6000, nullptr, nullptr, nullptr, napi_default, nullptr},
2103 {"SUB_DDM_RDB_Predicates_6100", nullptr, SUB_DDM_RDB_Predicates_6100, nullptr, nullptr, nullptr, napi_default, nullptr},
2104 {"SUB_DDM_RDB_Predicates_6200", nullptr, SUB_DDM_RDB_Predicates_6200, nullptr, nullptr, nullptr, napi_default, nullptr},
2105 {"SUB_DDM_RDB_Predicates_6300", nullptr, SUB_DDM_RDB_Predicates_6300, nullptr, nullptr, nullptr, napi_default, nullptr},
2106 {"SUB_DDM_RDB_Predicates_6400", nullptr, SUB_DDM_RDB_Predicates_6400, nullptr, nullptr, nullptr, napi_default, nullptr},
2107 {"SUB_DDM_RDB_Predicates_6500", nullptr, SUB_DDM_RDB_Predicates_6500, nullptr, nullptr, nullptr, napi_default, nullptr},
2108 {"SUB_DDM_RDB_Predicates_6600", nullptr, SUB_DDM_RDB_Predicates_6600, nullptr, nullptr, nullptr, napi_default, nullptr},
2109 {"SUB_DDM_RDB_Predicates_6700", nullptr, SUB_DDM_RDB_Predicates_6700, nullptr, nullptr, nullptr, napi_default, nullptr}
2110
2111 };
2112
2113
2114 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2115 return exports;
2116 }
2117 EXTERN_C_END
2118
2119
2120
2121
2122
2123 static napi_module demoModule = {
2124 .nm_version = 1,
2125 .nm_flags = 0,
2126 .nm_filename = nullptr,
2127 .nm_register_func = Init,
2128 .nm_modname = "predicates",
2129 .nm_priv = ((void *)0),
2130 .reserved = {0},
2131 };
2132
RegisterEntryModule(void)2133 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) {
2134 napi_module_register(&demoModule);
2135 }
2136