1 /*
2 * Copyright (c) 2021 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 "rdb_store_impl.h"
17
18 #include <gtest/gtest.h>
19
20 #include <map>
21 #include <string>
22
23 #include "types.h"
24 #include "single_kvstore.h"
25 #include "distributed_kv_data_manager.h"
26 #include "common.h"
27 #include "rdb_errno.h"
28 #include "rdb_helper.h"
29 #include "rdb_open_callback.h"
30 #include "relational_store_delegate.h"
31 #include "relational_store_manager.h"
32 #include "sqlite_connection.h"
33
34 using namespace testing::ext;
35 using namespace OHOS::NativeRdb;
36
37 class RdbStoreImplTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43
44 static const std::string DATABASE_NAME;
45
46 protected:
47 std::shared_ptr<RdbStore> store_;
48 };
49
50 constexpr const char *CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test "
51 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
52 "name TEXT NOT NULL, age INTEGER, salary REAL, "
53 "blobType BLOB)";
54
55 const std::string RdbStoreImplTest::DATABASE_NAME = RDB_TEST_PATH + "stepResultSet_impl_test.db";
56
57 class RdbStoreImplTestOpenCallback : public RdbOpenCallback {
58 public:
59 int OnCreate(RdbStore &store) override;
60 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
61 };
62
OnCreate(RdbStore & store)63 int RdbStoreImplTestOpenCallback::OnCreate(RdbStore &store)
64 {
65 return E_OK;
66 }
67
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)68 int RdbStoreImplTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
69 {
70 return E_OK;
71 }
72
SetUpTestCase(void)73 void RdbStoreImplTest::SetUpTestCase(void)
74 {
75 }
76
TearDownTestCase(void)77 void RdbStoreImplTest::TearDownTestCase(void)
78 {
79 }
80
SetUp(void)81 void RdbStoreImplTest::SetUp(void)
82 {
83 store_ = nullptr;
84 int errCode = RdbHelper::DeleteRdbStore(DATABASE_NAME);
85 EXPECT_EQ(E_OK, errCode);
86 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
87 RdbStoreImplTestOpenCallback helper;
88 store_ = RdbHelper::GetRdbStore(config, 1, helper, errCode);
89 EXPECT_NE(store_, nullptr);
90 EXPECT_EQ(errCode, E_OK);
91 }
92
TearDown(void)93 void RdbStoreImplTest::TearDown(void)
94 {
95 store_ = nullptr;
96 RdbHelper::ClearCache();
97 int errCode = RdbHelper::DeleteRdbStore(DATABASE_NAME);
98 EXPECT_EQ(E_OK, errCode);
99 }
100
101 /* *
102 * @tc.name: GetModifyTimeByRowIdTest_001
103 * @tc.desc: Normal testCase for GetModifyTime, get timestamp by id
104 * @tc.type: FUNC
105 */
106 HWTEST_F(RdbStoreImplTest, GetModifyTimeByRowIdTest_001, TestSize.Level2)
107 {
108 store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
109 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
110 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
111 int64_t rowId;
112 ValuesBucket valuesBucket;
113 valuesBucket.PutInt("data_key", ValueObject(1));
114 valuesBucket.PutInt("timestamp", ValueObject(1000000000));
115 int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
116 EXPECT_EQ(E_OK, errorCode);
117 EXPECT_EQ(1, rowId);
118
119 std::vector<RdbStore::PRIKey> PKey = { 1 };
120 std::map<RdbStore::PRIKey, RdbStore::Date> result =
121 store_->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
122 int size = result.size();
123 EXPECT_EQ(1, size);
124 EXPECT_EQ(100000, int64_t(result[1]));
125
126 store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log");
127 }
128
129 /* *
130 * @tc.name: GetModifyTimeByRowIdTest_002
131 * @tc.desc: Abnormal testCase for GetModifyTime, get timestamp by id,
132 * resultSet is empty or table name is not exist
133 * @tc.type: FUNC
134 */
135 HWTEST_F(RdbStoreImplTest, GetModifyTimeByRowIdTest_002, TestSize.Level2)
136 {
137 store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
138 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
139 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
140 int64_t rowId;
141 ValuesBucket valuesBucket;
142 valuesBucket.PutInt("data_key", ValueObject(2));
143 int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
144 EXPECT_EQ(E_OK, errorCode);
145 EXPECT_EQ(1, rowId);
146
147 // resultSet is empty
148 std::vector<RdbStore::PRIKey> PKey = { 1 };
149 std::map<RdbStore::PRIKey, RdbStore::Date> result =
150 store_->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
151 int size = result.size();
152 EXPECT_EQ(0, size);
153
154 // table name is not exist , resultSet is null
155 result = store_->GetModifyTime("test", "ROWID", PKey);
156 size = result.size();
157 EXPECT_EQ(0, size);
158
159 store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log");
160 }
161
162 /* *
163 * @tc.name: GetModifyTimeByRowIdTest_003
164 * @tc.desc: Abnormal testCase for GetModifyTime, get timestamp by id,
165 * resultSet is empty or table name is not exist
166 * @tc.type: FUNC
167 */
168 HWTEST_F(RdbStoreImplTest, GetModifyTimeByRowIdTest_003, TestSize.Level2)
169 {
170 store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
171 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
172 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
173 int64_t rowId;
174 ValuesBucket valuesBucket;
175 valuesBucket.PutInt("data_key", ValueObject(1));
176 int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
177 EXPECT_EQ(E_OK, errorCode);
178 EXPECT_EQ(1, rowId);
179
180 std::vector<RdbStore::PRIKey> PKey = { 1 };
181 RdbStore::ModifyTime resultMapTmp = store_->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
182 std::map<RdbStore::PRIKey, RdbStore::Date> resultMap = std::map<RdbStore::PRIKey, RdbStore::Date>(resultMapTmp);
183 EXPECT_EQ(1, resultMap.size());
184
185 RdbStore::ModifyTime resultPtrTmp = store_->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
186 std::shared_ptr<ResultSet> resultPtr = std::shared_ptr<ResultSet>(resultPtrTmp);
187 int count = 0;
188 resultPtr->GetRowCount(count);
189 EXPECT_EQ(1, count);
190
191 RdbStore::ModifyTime result = store_->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
192 RdbStore::PRIKey key = result.GetOriginKey(std::vector<uint8_t>{});
193 RdbStore::PRIKey monostate = std::monostate();
194 EXPECT_EQ(monostate, key);
195 EXPECT_EQ(8, result.GetMaxOriginKeySize());
196
197 store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log");
198 }
199
200 /* *
201 * @tc.name: GetModifyTime_001
202 * @tc.desc: Abnormal testCase for GetModifyTime, tablename columnName, keys is empty,
203 * and resultSet is null or empty
204 * @tc.type: FUNC
205 */
206 HWTEST_F(RdbStoreImplTest, GetModifyTime_001, TestSize.Level2)
207 {
208 store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
209 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
210 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
211
212 // table name is ""
213 std::vector<RdbStore::PRIKey> PKey = { 1 };
214 std::map<RdbStore::PRIKey, RdbStore::Date> result = store_->GetModifyTime("", "data_key", PKey);
215 int size = result.size();
216 EXPECT_EQ(0, size);
217
218 // table name is not exist , query resultSet is null
219 result = store_->GetModifyTime("test", "data_key", PKey);
220 size = result.size();
221 EXPECT_EQ(0, size);
222
223 // columnName is ""
224 result = store_->GetModifyTime("test", "", PKey);
225 size = result.size();
226 EXPECT_EQ(0, size);
227
228 // keys is empty
229 std::vector<RdbStore::PRIKey> emptyPRIKey;
230 result = store_->GetModifyTime("test", "data_key", emptyPRIKey);
231 size = result.size();
232 EXPECT_EQ(0, size);
233
234 store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log");
235 }
236
237 /* *
238 * @tc.name: GetModifyTime_002
239 * @tc.desc: Abnormal testCase for GetModifyTime, get timestamp by data3 ,if query resultSet is empty
240 * @tc.type: FUNC
241 */
242 HWTEST_F(RdbStoreImplTest, GetModifyTime_002, TestSize.Level2)
243 {
244 store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
245 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, hash_key INTEGER, "
246 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
247
248 std::vector<RdbStore::PRIKey> PKey = { 1 };
249 std::map<RdbStore::PRIKey, RdbStore::Date> result =
250 store_->GetModifyTime("rdbstoreimpltest_integer", "data3", PKey);
251 EXPECT_EQ(0, result.size());
252
253 store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log");
254 }
255
256 /* *
257 * @tc.name: Rdb_BatchInsertTest_001
258 * @tc.desc: Abnormal testCase for BatchInsert, if initialBatchValues is empty
259 * @tc.type: FUNC
260 */
261 HWTEST_F(RdbStoreImplTest, Rdb_BatchInsertTest_001, TestSize.Level2)
262 {
263 std::vector<ValuesBucket> valuesBuckets;
264 int64_t insertNum = 1;
265 int ret = store_->BatchInsert(insertNum, "test", valuesBuckets);
266 EXPECT_EQ(0, insertNum);
267 EXPECT_EQ(E_OK, ret);
268 }
269
270 /* *
271 * @tc.name: Rdb_BatchInsertTest_002
272 * @tc.desc: Abnormal testCase for BatchInsert, if column is not exist.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(RdbStoreImplTest, Rdb_BatchInsertTest_002, TestSize.Level2)
276 {
277 store_->ExecuteSql("CREATE TABLE batchInsertTest "
278 "(id INTEGER PRIMARY KEY AUTOINCREMENT, data INTEGER, data1 INTEGER, "
279 "data2 INTEGER);");
280 ValuesBucket valuesBucket;
281 valuesBucket.PutInt("data", ValueObject(0));
282 valuesBucket.PutInt("data1", ValueObject(1));
283 valuesBucket.PutInt("data2", ValueObject(2));
284 valuesBucket.PutInt("NonexistentColumn", ValueObject(3));
285 std::vector<ValuesBucket> valuesBuckets = { valuesBucket };
286 int64_t insertNum = 1;
287 int ret = store_->BatchInsert(insertNum, "batchInsertTest", valuesBuckets);
288 EXPECT_EQ(-1, insertNum);
289 EXPECT_EQ(E_OK, ret);
290 }
291
292 /* *
293 * @tc.name: Rdb_QueryTest_001
294 * @tc.desc: Abnormal testCase for Query, if table name is empty
295 * @tc.type: FUNC
296 */
297 HWTEST_F(RdbStoreImplTest, Rdb_QueryTest_001, TestSize.Level2)
298 {
299 int errCode = E_OK;
300 store_->Query(errCode, true, "", {}, "", std::vector<ValueObject>{}, "", "", "", 1, 0);
301 EXPECT_NE(E_OK, errCode);
302 }
303
304 /* *
305 * @tc.name: Rdb_QueryTest_002
306 * @tc.desc: Normal testCase for Query, get * form test
307 * @tc.type: FUNC
308 */
309 HWTEST_F(RdbStoreImplTest, Rdb_QueryTest_002, TestSize.Level2)
310 {
311 store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
312 "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
313 int errCode = E_OK;
314 store_->Query(errCode, true, "test", {}, "", std::vector<ValueObject>{}, "", "", "", 1, 0);
315 EXPECT_EQ(E_OK, errCode);
316
317 store_->ExecuteSql("DROP TABLE IF EXISTS test");
318 }
319
320 /* *
321 * @tc.name: Rdb_RemoteQueryTest_001
322 * @tc.desc: Abnormal testCase for RemoteQuery
323 * @tc.type: FUNC
324 */
325 HWTEST_F(RdbStoreImplTest, Rdb_RemoteQueryTest_001, TestSize.Level2)
326 {
327 int errCode = E_OK;
328 AbsRdbPredicates predicates("test");
329 predicates.EqualTo("id", 1);
330
331 // GetRdbService failed if rdbstoreconfig bundlename_ empty
332 auto ret = store_->RemoteQuery("", predicates, {}, errCode);
333 EXPECT_EQ(E_INVALID_ARGS, errCode);
334 EXPECT_EQ(nullptr, ret);
335 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
336
337 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
338 config.SetName("RdbStore_impl_test.db");
339 config.SetBundleName("com.example.distributed.rdb");
340 RdbStoreImplTestOpenCallback helper;
341 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
342 EXPECT_EQ(E_OK, errCode);
343
344 // GetRdbService succeeded if configuration file has already been configured
345 ret = store->RemoteQuery("", predicates, {}, errCode);
346 EXPECT_NE(E_OK, errCode);
347 EXPECT_EQ(nullptr, ret);
348
349 store = nullptr;
350 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
351 }
352
353 /* *
354 * @tc.name: Rdb_RollbackTest_001
355 * @tc.desc: Abnormal testCase for Rollback
356 * @tc.type: FUNC
357 */
358 HWTEST_F(RdbStoreImplTest, Rdb_RollbackTest_001, TestSize.Level2)
359 {
360 int ret = store_->RollBack();
361 EXPECT_EQ(OHOS::NativeRdb::E_NO_TRANSACTION_IN_SESSION, ret);
362 }
363
364 /* *
365 * @tc.name: Rdb_CommitTest_001
366 * @tc.desc: Abnormal testCase for Commit,if not use BeginTransaction
367 * @tc.type: FUNC
368 */
369 HWTEST_F(RdbStoreImplTest, Rdb_CommitTest_001, TestSize.Level2)
370 {
371 int ret = store_->Commit();
372 EXPECT_EQ(E_OK, ret);
373 }
374
375 /* *
376 * @tc.name: Rdb_BackupTest_001
377 * @tc.desc: Abnormal testCase for Backup
378 * @tc.type: FUNC
379 */
380 HWTEST_F(RdbStoreImplTest, Rdb_BackupTest_001, TestSize.Level2)
381 {
382 int errCode = E_OK;
383 std::string databasePath = RDB_TEST_PATH + "test.db";
384 std::vector<uint8_t> destEncryptKey;
385 // isEncrypt_ is false, and destEncryptKey is emtpy
386 errCode = store_->Backup(databasePath, destEncryptKey);
387 EXPECT_EQ(E_OK, errCode);
388 RdbHelper::DeleteRdbStore(databasePath);
389
390 // isEncrypt_ is false, and destEncryptKey is not emtpy
391 destEncryptKey.push_back(1);
392 errCode = store_->Backup(databasePath, destEncryptKey);
393 EXPECT_EQ(E_OK, errCode);
394 store_ = nullptr;
395 RdbHelper::DeleteRdbStore(DATABASE_NAME);
396 RdbHelper::DeleteRdbStore(databasePath);
397
398 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
399 config.SetEncryptStatus(true);
400 RdbStoreImplTestOpenCallback helper;
401 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
402 EXPECT_EQ(E_OK, errCode);
403
404 // isEncrypt_ is true, and destEncryptKey is not emtpy
405 errCode = store->Backup(databasePath, destEncryptKey);
406 EXPECT_EQ(E_OK, errCode);
407 RdbHelper::DeleteRdbStore(databasePath);
408
409 // isEncrypt_ is true, and destEncryptKey is not emtpy
410 destEncryptKey.pop_back();
411 errCode = store->Backup(databasePath, destEncryptKey);
412 EXPECT_EQ(E_OK, errCode);
413 store = nullptr;
414 RdbHelper::DeleteRdbStore(databasePath);
415 RdbHelper::DeleteRdbStore(DATABASE_NAME);
416 }
417
418 /* *
419 * @tc.name: Rdb_BackupTest_009
420 * @tc.desc: Abnormal testCase for Backup
421 * @tc.type: FUNC
422 */
423 HWTEST_F(RdbStoreImplTest, Rdb_BackupTest_009, TestSize.Level2)
424 {
425 OHOS::DistributedKv::AppId appId;
426 OHOS::DistributedKv::StoreId storeId64;
427 OHOS::DistributedKv::DistributedKvDataManager manager;
428 OHOS::DistributedKv::Options create;
429
430 std::shared_ptr<OHOS::ExecutorPool> executors;
431 manager.SetExecutors(executors);
432 appId.appId = "ohos.kvdatamanager.test";
433 storeId64.storeId = "a000000000b000000000c000000000d000000000e000000000f000000000g000";
434 create.createIfMissing = true;
435 create.encrypt = false;
436 create.securityLevel = OHOS::DistributedKv::SecurityLevel::S1;
437 create.autoSync = true;
438 create.kvStoreType = OHOS::DistributedKv::KvStoreType::SINGLE_VERSION;
439 create.area = OHOS::DistributedKv::Area::EL1;
440 create.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
441 mkdir(create.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
442 std::shared_ptr<OHOS::DistributedKv::SingleKvStore> notExistKvStore;
443 int status = manager.GetSingleKvStore(create, appId, storeId64, notExistKvStore);
444 ASSERT_EQ(status, OHOS::DistributedKv::Status::SUCCESS);
445 EXPECT_NE(notExistKvStore, nullptr);
446
447 const std::string attachedName = "attached";
448 int errCode = E_OK;
449 RdbStoreConfig config1(RDB_TEST_PATH + "stepReSUltSet_lmpl_testA.db");
450 config1.SetSecurityLevel(SecurityLevel::S1);
451 config1.SetEncryptStatus(true);
452 RdbStoreImplTestOpenCallback helper;
453 std::shared_ptr<RdbStore> storeA = RdbHelper::GetRdbStore(config1, 1, helper, errCode);
454 ASSERT_NE(storeA, nullptr);
455 ASSERT_EQ(errCode, E_OK);
456
457 RdbStoreConfig config2(RDB_TEST_PATH + "stepResultSet_lmpl_testB.db");
458 config2.SetSecurityLevel(SecurityLevel::S1);
459 config2.SetEncryptStatus(true);
460 std::shared_ptr<RdbStore> storeB = RdbHelper::GetRdbStore(config2, 1, helper, errCode);
461 ASSERT_NE(storeB, nullptr);
462 ASSERT_EQ(errCode, E_OK);
463
464 std::pair<int32_t, int32_t> results = storeB->Attach(config1, attachedName, 2);
465 int32_t result1 = results.first;
466 ASSERT_EQ(result1, E_OK);
467 manager.CloseAllKvStore(appId);
468 manager.DeleteAllKvStore(appId, create.baseDir);
469 }
470
471 /* *
472 * @tc.name: Rdb_SqlitConnectionTest_001
473 * @tc.desc: Abnormal testCase for SetPageSize,
474 * return ok if open db again and set same page size
475 * @tc.type: FUNC
476 */
477 HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionTest_001, TestSize.Level2)
478 {
479 const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionOpenTest.db";
480 RdbStoreConfig config(DATABASE_NAME);
481 config.SetReadOnly(false);
482 config.SetPageSize(1024);
483 auto [errCode, connection] = Connection::Create(config, true);
484 EXPECT_NE(nullptr, connection);
485 auto [err, statement] = connection->CreateStatement("PRAGMA page_size", connection);
486 auto [error, object] = statement->ExecuteForValue();
487 EXPECT_EQ(E_OK, error);
488 EXPECT_EQ(1024, static_cast<int64_t>(object));
489
490 std::tie(errCode, connection) = Connection::Create(config, true);
491 EXPECT_NE(nullptr, connection);
492 }
493
494 /* *
495 * @tc.name: Rdb_ConnectionPoolTest_001
496 * @tc.desc: Abnormal testCase for ConfigLocale
497 * @tc.type: FUNC
498 */
499 HWTEST_F(RdbStoreImplTest, Rdb_ConnectionPoolTest_001, TestSize.Level2)
500 {
501 const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionOpenTest.db";
502 int errCode = E_OK;
503 RdbStoreConfig config(DATABASE_NAME);
504 config.SetReadConSize(1);
505 config.SetStorageMode(StorageMode::MODE_DISK);
506
507 RdbStoreImplTestOpenCallback helper;
508 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
509 EXPECT_EQ(E_OK, errCode);
510
511 auto connectionPool = ConnectionPool::Create(config, errCode);
512 EXPECT_NE(nullptr, connectionPool);
513 EXPECT_EQ(E_OK, errCode);
514
515 // connecting database
516 auto connection = connectionPool->AcquireConnection(true);
517 EXPECT_NE(nullptr, connection);
518 errCode = connectionPool->ConfigLocale("AbnormalTest");
519 EXPECT_EQ(OHOS::NativeRdb::E_DATABASE_BUSY, errCode);
520
521 store = nullptr;
522 RdbHelper::DeleteRdbStore(DATABASE_NAME);
523 }
524
525 /* *
526 * @tc.name: Rdb_ConnectionPoolTest_002
527 * @tc.desc: Abnormal testCase for AcquireConnection/AcquireTransaction
528 * @tc.type: FUNC
529 */
530 HWTEST_F(RdbStoreImplTest, Rdb_ConnectionPoolTest_002, TestSize.Level2)
531 {
532 const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionTest.db";
533 int errCode = E_OK;
534 RdbStoreConfig config(DATABASE_NAME);
535 config.SetReadConSize(1);
536 config.SetStorageMode(StorageMode::MODE_DISK);
537 auto connectionPool = ConnectionPool::Create(config, errCode);
538 EXPECT_NE(nullptr, connectionPool);
539 EXPECT_EQ(E_OK, errCode);
540
541 // repeat AcquireReader without release
542 auto connection = connectionPool->AcquireConnection(true);
543 EXPECT_NE(nullptr, connection);
544 connection = connectionPool->AcquireConnection(true);
545 EXPECT_NE(nullptr, connection);
546 connection = connectionPool->AcquireConnection(true);
547 EXPECT_NE(nullptr, connection);
548
549 // repeat AcquireWriter without release
550 connection = connectionPool->AcquireConnection(false);
551 EXPECT_NE(nullptr, connection);
552 connection = connectionPool->AcquireConnection(false);
553 EXPECT_EQ(nullptr, connection);
554 connection = connectionPool->AcquireConnection(false);
555 EXPECT_NE(nullptr, connection);
556
557 // repeat AcquireTransaction without release
558 errCode = connectionPool->AcquireTransaction();
559 EXPECT_EQ(E_OK, errCode);
560 errCode = connectionPool->AcquireTransaction();
561 EXPECT_NE(E_OK, errCode);
562 connectionPool->ReleaseTransaction();
563 }
564
565 /* *
566 * @tc.name: Rdb_ConnectionPoolTest_003
567 * @tc.desc: Abnormal testCase for ChangeDbFileForRestore
568 * @tc.type: FUNC
569 */
570 HWTEST_F(RdbStoreImplTest, Rdb_ConnectionPoolTest_0023, TestSize.Level2)
571 {
572 const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionTest.db";
573 int errCode = E_OK;
574 RdbStoreConfig config(DATABASE_NAME);
575 config.SetReadConSize(1);
576 config.SetStorageMode(StorageMode::MODE_DISK);
577 auto connectionPool = ConnectionPool::Create(config, errCode);
578 EXPECT_NE(nullptr, connectionPool);
579 EXPECT_EQ(E_OK, errCode);
580
581 const std::string newPath = DATABASE_NAME;
582 const std::string backupPath = DATABASE_NAME;
583 const std::vector<uint8_t> newKey;
584
585 // newPath == currentPath, writeConnectionUsed == true
586 auto connection = connectionPool->AcquireConnection(false);
587 SlaveStatus curStatus;
588 errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey, curStatus);
589 EXPECT_EQ(E_ERROR, errCode);
590 connection = nullptr;
591 // newPath == currentPath
592 errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey, curStatus);
593 EXPECT_NE(E_OK, errCode);
594 // newPath != currentPath
595 const std::string newPath2 = RDB_TEST_PATH + "tmp.db";
596 errCode = connectionPool->ChangeDbFileForRestore(newPath2, backupPath, newKey, curStatus);
597 EXPECT_EQ(E_ERROR, errCode);
598 }
599
600 HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_001, TestSize.Level2)
601 {
602 const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionOpenTest.db";
603 RdbStoreConfig config(DATABASE_NAME);
604 config.SetReadOnly(false);
605 config.SetPageSize(1024);
606 auto [errCode, connection] = SqliteConnection::Create(config, true);
607 EXPECT_NE(nullptr, connection);
608 RdbStoreImplTestOpenCallback helper;
609 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
610 EXPECT_NE(nullptr, store);
611 }
612
613 HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_002, TestSize.Level2)
614 {
615 int errCode = E_OK;
616 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
617 config.SetReadOnly(false);
618 config.SetPageSize(1024);
619 config.SetBundleName("callback.test2");
620 config.SetSearchable(true);
621 config.SetStorageMode(StorageMode::MODE_DISK);
622 // register callback
623 RdbStoreImplTestOpenCallback helper;
624 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
625 EXPECT_NE(nullptr, store);
626 store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t2;");
627 store->ExecuteSql("CREATE TABLE if not exists test_callback_t2 "
628 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
629 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
630 // set TrackerTable
631 DistributedDB::TrackerSchema tracker;
632 tracker.tableName = "test_callback_t2";
633 tracker.extendColNames = { "id" };
634 tracker.trackerColNames = { "id", "timestamp" };
635 using Delegate = DistributedDB::RelationalStoreDelegate;
636 DistributedDB::RelationalStoreManager rStoreManager("test_app", "test_user_id", 0);
637 Delegate::Option option;
638 Delegate *g_delegate = nullptr;
639 EXPECT_EQ(RdbStoreImplTest::DATABASE_NAME, "/data/test/stepResultSet_impl_test.db");
640 int status = rStoreManager.OpenStore(RdbStoreImplTest::DATABASE_NAME, "test_callback_t2", option, g_delegate);
641 EXPECT_EQ(E_OK, status);
642 auto delegatePtr = std::shared_ptr<Delegate>(
__anoncdeccf470102(Delegate *delegate) 643 g_delegate, [&rStoreManager](Delegate *delegate) { rStoreManager.CloseStore(delegate); });
644 int setStatus = delegatePtr->SetTrackerTable(tracker);
645 EXPECT_EQ(E_OK, setStatus);
646
647 int64_t rowId;
648 ValuesBucket valuesBucket;
649 valuesBucket.PutInt("data_key", ValueObject(1));
650 valuesBucket.PutInt("timestamp", ValueObject(1000000000));
651 int errorCode = store->Insert(rowId, "test_callback_t2", valuesBucket);
652 EXPECT_EQ(E_OK, errorCode);
653 EXPECT_EQ(1, rowId);
654 store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t2;");
655 }
656
657 HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_003, TestSize.Level2)
658 {
659 int errCode = E_OK;
660 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
661 config.SetReadOnly(false);
662 config.SetPageSize(1024);
663 config.SetBundleName("callback.test3");
664 config.SetSearchable(true);
665 config.SetStorageMode(StorageMode::MODE_DISK);
666
667 RdbStoreImplTestOpenCallback helper;
668 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
669
670 store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t3;");
671
672 store->ExecuteSql("CREATE TABLE if not exists test_callback_t3 "
673 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
674 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
675 // set TrackerTable
676 DistributedDB::TrackerSchema tracker;
677 tracker.tableName = "test_callback_t3";
678 tracker.extendColNames = { "id" };
679 tracker.trackerColNames = { "id", "timestamp" };
680 using Delegate = DistributedDB::RelationalStoreDelegate;
681 DistributedDB::RelationalStoreManager rStoreManager("test_app", "test_user_id", 0);
682 Delegate::Option option;
683 Delegate *g_delegate = nullptr;
684 EXPECT_EQ(RdbStoreImplTest::DATABASE_NAME, "/data/test/stepResultSet_impl_test.db");
685 int status = rStoreManager.OpenStore(RdbStoreImplTest::DATABASE_NAME, "test_callback_t3", option, g_delegate);
686 EXPECT_EQ(E_OK, status);
687 auto delegatePtr = std::shared_ptr<Delegate>(
__anoncdeccf470202(Delegate *delegate) 688 g_delegate, [&rStoreManager](Delegate *delegate) { rStoreManager.CloseStore(delegate); });
689 int setStatus = delegatePtr->SetTrackerTable(tracker);
690 EXPECT_EQ(E_OK, setStatus);
691
692 int64_t rowId;
693 ValuesBucket valuesBucket;
694 valuesBucket.PutInt("data_key", ValueObject(1));
695 valuesBucket.PutInt("timestamp", ValueObject(1000000000));
696 int errorCode = store->Insert(rowId, "test_callback_t3", valuesBucket);
697 EXPECT_EQ(E_OK, errorCode);
698 EXPECT_EQ(1, rowId);
699 errorCode = store->ExecuteSql("UPDATE test_callback_t3 SET timestamp = 100 WHERE id = 1;");
700 EXPECT_EQ(E_OK, errorCode);
701
702 store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t3;");
703 }
704
705 /* *
706 * @tc.name: Rdb_QuerySharingResourceTest_001
707 * @tc.desc: QuerySharingResource testCase
708 * @tc.type: FUNC
709 */
710 HWTEST_F(RdbStoreImplTest, Rdb_QuerySharingResourceTest_001, TestSize.Level2)
711 {
712 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
713 int errCode = E_OK;
714 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
715 config.SetName("RdbStore_impl_test.db");
716 config.SetBundleName("com.example.distributed.rdb");
717
718 RdbStoreImplTestOpenCallback helper;
719 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
720 EXPECT_NE(store, nullptr);
721 EXPECT_EQ(errCode, E_OK);
722 AbsRdbPredicates predicates("test");
723 predicates.EqualTo("id", 1);
724
725 auto ret = store->QuerySharingResource(predicates, {});
726 EXPECT_NE(E_OK, ret.first);
727 EXPECT_EQ(nullptr, ret.second);
728 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
729 }
730
731 /* *
732 * @tc.name: Rdb_QuerySharingResourceTest_002
733 * @tc.desc: QuerySharingResource testCase
734 * @tc.type: FUNC
735 */
736 HWTEST_F(RdbStoreImplTest, Rdb_QuerySharingResourceTest_002, TestSize.Level2)
737 {
738 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
739 int errCode = E_OK;
740 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
741 config.SetName("RdbStore_impl_test.db");
742 config.SetBundleName("com.example.distributed.rdb");
743
744 RdbStoreImplTestOpenCallback helper;
745 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
746 EXPECT_NE(store, nullptr);
747 EXPECT_EQ(errCode, E_OK);
748 store->ExecuteSql("CREATE TABLE test_resource "
749 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
750 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
751 int64_t rowId;
752 ValuesBucket valuesBucket;
753 valuesBucket.PutInt("data_key", ValueObject(1));
754 valuesBucket.PutInt("timestamp", ValueObject(1000000000));
755 int errorCode = store->Insert(rowId, "test_resource", valuesBucket);
756 EXPECT_EQ(E_OK, errorCode);
757 EXPECT_EQ(1, rowId);
758 AbsRdbPredicates predicates("test_resource");
759 predicates.EqualTo("data_key", 1);
760
761 auto [status, resultSet] = store->QuerySharingResource(predicates, { "id", "data_key" });
762 EXPECT_NE(E_OK, status);
763 ASSERT_EQ(nullptr, resultSet);
764
765 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
766 }
767
768 /* *
769 * @tc.name: CleanDirtyDataTest_001
770 * @tc.desc: Abnormal testCase for CleanDirtyData
771 * @tc.type: FUNC
772 */
773 HWTEST_F(RdbStoreImplTest, Abnormal_CleanDirtyDataTest_001, TestSize.Level2)
774 {
775 store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
776 "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
777 int errCode = E_OK;
778
779 // tabel is empty
780 std::string table = "";
781 uint64_t cursor = UINT64_MAX;
782 errCode = RdbStoreImplTest::store_->CleanDirtyData(table, cursor);
783 EXPECT_EQ(E_INVALID_ARGS, errCode);
784
785 table = "test";
786 errCode = RdbStoreImplTest::store_->CleanDirtyData(table, cursor);
787 EXPECT_EQ(E_ERROR, errCode);
788 store_->ExecuteSql("DROP TABLE IF EXISTS test");
789 }
790
791 /* *
792 * @tc.name: ClearCacheTest_001
793 * @tc.desc: Normal testCase for ClearCache
794 * @tc.type: FUNC
795 */
796 HWTEST_F(RdbStoreImplTest, Normal_ClearCacheTest_001, TestSize.Level2)
797 {
798 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
799 int errCode = E_OK;
800 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
801 RdbStoreImplTestOpenCallback helper;
802 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
803 EXPECT_NE(nullptr, store);
804 EXPECT_EQ(E_OK, errCode);
805 store->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
806 "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
807 int64_t id;
808 ValuesBucket valuesBucket;
809 for (int i = 0; i < 1000; ++i) {
810 valuesBucket.PutString("data1", std::string(1024 * 1024, 'a'));
811 valuesBucket.PutInt("data2", 20);
812 errCode = store->Insert(id, "test", valuesBucket);
813 }
814 EXPECT_EQ(errCode, E_OK);
815 EXPECT_EQ(1000, id);
816
817 int rowCount;
818 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
819 EXPECT_NE(resultSet, nullptr);
820 resultSet->GetRowCount(rowCount);
821 EXPECT_EQ(rowCount, 1000);
822 int64_t currentMemory = sqlite3_memory_used();
823 EXPECT_EQ(E_OK, resultSet->Close());
824 EXPECT_LT(sqlite3_memory_used(), currentMemory);
825 }
826
827 /* *
828 * @tc.name: ClearCacheTest_002
829 * @tc.desc: Normal testCase for ClearCache
830 * @tc.type: FUNC
831 */
832 HWTEST_F(RdbStoreImplTest, Normal_ClearCacheTest_002, TestSize.Level2)
833 {
834 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
835 int errCode = E_OK;
836 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
837 RdbStoreImplTestOpenCallback helper;
838 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
839 EXPECT_NE(nullptr, store);
840 EXPECT_EQ(E_OK, errCode);
841 store->ExecuteSql("CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
842 "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
843 int64_t id;
844 ValuesBucket valuesBucket;
845 valuesBucket.PutString("data1", std::string(0.5 * 1024 * 1024, 'a'));
846 valuesBucket.PutInt("data2", 20);
847 errCode = store->Insert(id, "test1", valuesBucket);
848 EXPECT_EQ(errCode, E_OK);
849 EXPECT_EQ(1, id);
850 int64_t currentMemory = sqlite3_memory_used();
851 valuesBucket.PutString("data1", std::string(0.5 * 1024 * 1024, 'a'));
852 valuesBucket.PutInt("data2", 20);
853 errCode = store->Insert(id, "test1", valuesBucket);
854 EXPECT_EQ(errCode, E_OK);
855 EXPECT_EQ(2, id);
856 EXPECT_LT(sqlite3_memory_used(), currentMemory);
857 }
858
859 /* *
860 * @tc.name: ClearCacheTest_003
861 * @tc.desc: Normal testCase for ClearCache
862 * @tc.type: FUNC
863 */
864 HWTEST_F(RdbStoreImplTest, Normal_ClearCacheTest_003, TestSize.Level2)
865 {
866 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
867 int errCode = E_OK;
868 int clearMemorySize = 1024 * 1024;
869 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
870 config.SetClearMemorySize(1024 * 1024 + 1);
871 EXPECT_EQ(clearMemorySize, config.GetClearMemorySize());
872 config.SetClearMemorySize(-1);
873 EXPECT_EQ(clearMemorySize, config.GetClearMemorySize());
874 config.SetClearMemorySize(10240);
875 RdbStoreImplTestOpenCallback helper;
876 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
877 ASSERT_NE(nullptr, store);
878 EXPECT_EQ(E_OK, errCode);
879 }
880
881 /* *
882 * @tc.name: LockCloudContainerTest
883 * @tc.desc: lock cloudContainer testCase
884 * @tc.type: FUNC
885 */
886 HWTEST_F(RdbStoreImplTest, LockCloudContainerTest, TestSize.Level2)
887 {
888 int errCode = E_OK;
889 // GetRdbService failed if rdbstoreconfig bundlename_ empty
890 auto ret = store_->LockCloudContainer();
891 EXPECT_EQ(E_INVALID_ARGS, ret.first);
892 EXPECT_EQ(0, ret.second);
893 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
894
895 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
896 config.SetName("RdbStore_impl_test.db");
897 config.SetBundleName("com.example.distributed.rdb");
898 RdbStoreImplTestOpenCallback helper;
899 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
900 EXPECT_EQ(E_OK, errCode);
901 // GetRdbService succeeded if configuration file has already been configured
902 ret = store->LockCloudContainer();
903 EXPECT_NE(E_OK, ret.first);
904 store = nullptr;
905 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
906 }
907
908 /* *
909 * @tc.name: UnlockCloudContainerTest
910 * @tc.desc: unlock cloudContainer testCase
911 * @tc.type: FUNC
912 */
913 HWTEST_F(RdbStoreImplTest, UnlockCloudContainerTest, TestSize.Level2)
914 {
915 int errCode = E_OK;
916 // GetRdbService failed if rdbstoreconfig bundlename_ empty
917 auto result = store_->UnlockCloudContainer();
918 EXPECT_EQ(E_INVALID_ARGS, result);
919 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
920
921 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
922 config.SetName("RdbStore_impl_test.db");
923 config.SetBundleName("com.example.distributed.rdb");
924 RdbStoreImplTestOpenCallback helper;
925 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
926 EXPECT_EQ(E_OK, errCode);
927 // GetRdbService succeeded if configuration file has already been configured
928 result = store->UnlockCloudContainer();
929 EXPECT_NE(E_OK, result);
930 store = nullptr;
931 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
932 }
933
934 /* *
935 * @tc.name: LockCloudContainerTest001
936 * @tc.desc: lock cloudContainer testCase
937 * @tc.type: FUNC
938 */
939 HWTEST_F(RdbStoreImplTest, LockCloudContainerTest001, TestSize.Level2)
940 {
941 int errCode = E_OK;
942 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
943 config.SetName("RdbStore_impl_test.db");
944 config.SetBundleName("com.example.distributed.rdb");
945 RdbStoreImplTestOpenCallback helper;
946 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
947 ASSERT_NE(store, nullptr);
948 EXPECT_EQ(E_OK, errCode);
949 // GetRdbService succeeded if configuration file has already been configured
950 auto ret = store->RdbStore::LockCloudContainer();
951 EXPECT_EQ(E_OK, ret.first);
952 EXPECT_EQ(0, ret.second);
953 store = nullptr;
954 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
955 }
956
957 /* *
958 * @tc.name: UnlockCloudContainerTest001
959 * @tc.desc: unlock cloudContainer testCase
960 * @tc.type: FUNC
961 */
962 HWTEST_F(RdbStoreImplTest, UnlockCloudContainerTest001, TestSize.Level2)
963 {
964 int errCode = E_OK;
965 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
966 config.SetName("RdbStore_impl_test.db");
967 config.SetBundleName("com.example.distributed.rdb");
968 RdbStoreImplTestOpenCallback helper;
969 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
970 ASSERT_NE(store, nullptr);
971 EXPECT_EQ(E_OK, errCode);
972 // GetRdbService succeeded if configuration file has already been configured
973 auto result = store->RdbStore::UnlockCloudContainer();
974 EXPECT_EQ(E_OK, result);
975 store = nullptr;
976 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
977 }
978
979 /* *
980 * @tc.name: SetSearchableTest
981 * @tc.desc: SetSearchable testCase
982 * @tc.type: FUNC
983 */
984 HWTEST_F(RdbStoreImplTest, SetSearchableTest, TestSize.Level2)
985 {
986 int errCode = E_OK;
987 RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
988 config.SetBundleName("");
989 RdbStoreImplTestOpenCallback helper;
990 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
991 EXPECT_EQ(E_OK, errCode);
992
993 int result = store->SetSearchable(true);
994 EXPECT_EQ(E_INVALID_ARGS, result);
995 RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
996
997 config.SetBundleName("com.example.distributed.rdb");
998 EXPECT_EQ(E_OK, errCode);
999 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1000 EXPECT_EQ(E_OK, errCode);
1001 result = store->SetSearchable(true);
1002 EXPECT_EQ(E_OK, result);
1003 }
1004
1005 /* *
1006 * @tc.name: CreateTransaction_001
1007 * @tc.desc: create the DEFERRED, IMMEDIATE, EXCLUSIVE transaction.
1008 * @tc.type: FUNC
1009 */
1010 HWTEST_F(RdbStoreImplTest, CreateTransaction_001, TestSize.Level1)
1011 {
1012 auto [errCode, trans] = store_->CreateTransaction(Transaction::DEFERRED);
1013 ASSERT_EQ(errCode, E_OK);
1014 ASSERT_NE(trans, nullptr);
1015 trans = nullptr;
1016 std::tie(errCode, trans) = store_->CreateTransaction(Transaction::IMMEDIATE);
1017 ASSERT_EQ(errCode, E_OK);
1018 ASSERT_NE(trans, nullptr);
1019 trans = nullptr;
1020 std::tie(errCode, trans) = store_->CreateTransaction(Transaction::EXCLUSIVE);
1021 ASSERT_EQ(errCode, E_OK);
1022 ASSERT_NE(trans, nullptr);
1023 }
1024
1025 /* *
1026 * @tc.name: CreateTransaction_002
1027 * @tc.desc: create the invalid type transaction.
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(RdbStoreImplTest, CreateTransaction_002, TestSize.Level1)
1031 {
1032 auto [errCode, trans] = store_->CreateTransaction(-1);
1033 ASSERT_EQ(errCode, E_INVALID_ARGS);
1034 ASSERT_EQ(trans, nullptr);
1035 std::tie(errCode, trans) = store_->CreateTransaction(Transaction::TRANS_BUTT);
1036 ASSERT_EQ(errCode, E_INVALID_ARGS);
1037 ASSERT_EQ(trans, nullptr);
1038 std::tie(errCode, trans) = store_->CreateTransaction(100);
1039 ASSERT_EQ(errCode, E_INVALID_ARGS);
1040 ASSERT_EQ(trans, nullptr);
1041 }
1042
1043 /* *
1044 * @tc.name: CreateTransaction_003
1045 * @tc.desc: create the over the max trans.
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(RdbStoreImplTest, CreateTransaction_003, TestSize.Level1)
1049 {
1050 constexpr size_t MAX_TRANS = 4;
1051 std::vector<std::shared_ptr<Transaction>> entries;
1052 int32_t errCode = E_OK;
1053 std::shared_ptr<Transaction> trans = nullptr;
1054 for (int i = 0; i < 100; ++i) {
1055 std::tie(errCode, trans) = store_->CreateTransaction(Transaction::DEFERRED);
1056 if (trans == nullptr) {
1057 break;
1058 }
1059 entries.push_back(std::move(trans));
1060 }
1061 ASSERT_EQ(errCode, E_DATABASE_BUSY);
1062 ASSERT_EQ(entries.size(), MAX_TRANS);
1063 }
1064
1065 /* *
1066 * @tc.name: CreateTransaction_004
1067 * @tc.desc: create the auto release trans.
1068 * @tc.type: FUNC
1069 */
1070 HWTEST_F(RdbStoreImplTest, CreateTransaction_004, TestSize.Level1)
1071 {
1072 int i = 0;
1073 for (i = 0; i < 20; ++i) {
1074 auto [errCode, trans] = store_->CreateTransaction(Transaction::EXCLUSIVE);
1075 ASSERT_EQ(errCode, E_OK);
1076 ASSERT_NE(trans, nullptr);
1077 }
1078 ASSERT_EQ(i, 20);
1079 }
1080
1081 /* *
1082 * @tc.name: BatchInsertWithConflictResolution_001
1083 * @tc.desc: BatchInsertWithConflictResolution when violation the unique constraint.
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_001, TestSize.Level1)
1087 {
1088 std::string tableName = "BatchInsertWithConflictResolutionTest";
1089 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1090 auto res =
1091 store_->Execute("CREATE TABLE " + tableName + " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL)");
1092 ASSERT_EQ(res.first, E_OK);
1093
1094 ValuesBuckets rows;
1095 for (int i = 0; i < 5; i++) {
1096 ValuesBucket row;
1097 row.Put("id", i);
1098 row.Put("name", "Jim");
1099 rows.Put(row);
1100 }
1101 Transaction::Row row;
1102 row.Put("id", 2);
1103 row.Put("name", "Jim");
1104 auto result = store_->Insert(tableName, row);
1105 ASSERT_EQ(result.first, E_OK);
1106 ASSERT_EQ(result.second, 2);
1107 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1108 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1109 ASSERT_EQ(result.second, 0);
1110
1111 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1112 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1113 ASSERT_EQ(result.second, 0);
1114
1115 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1116 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1117 ASSERT_EQ(result.second, 0);
1118
1119 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1120 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1121 ASSERT_EQ(result.second, 2);
1122
1123 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1124 ASSERT_EQ(result.first, E_OK);
1125 ASSERT_EQ(result.second, 2);
1126
1127 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1128 ASSERT_EQ(result.first, E_OK);
1129 ASSERT_EQ(result.second, 5);
1130
1131 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1132 ASSERT_NE(resultSet, nullptr);
1133 int rowCount;
1134 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1135 ASSERT_EQ(rowCount, 5);
1136 }
1137
1138 /* *
1139 * @tc.name: BatchInsertWithConflictResolution_002
1140 * @tc.desc: BatchInsertWithConflictResolution when violation the not null constraint.
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_002, TestSize.Level1)
1144 {
1145 std::string tableName = "BatchInsertWithConflictResolutionTest";
1146 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1147 auto res =
1148 store_->Execute("CREATE TABLE " + tableName + " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL)");
1149 ASSERT_EQ(res.first, E_OK);
1150
1151 ValuesBuckets rows;
1152 for (int i = 0; i < 5; i++) {
1153 ValuesBucket row;
1154 row.Put("id", i);
1155 row.Put("name", i == 2 ? ValueObject() : "Jim");
1156 rows.Put(row);
1157 }
1158 auto result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1159 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1160 ASSERT_EQ(result.second, 0);
1161
1162 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1163 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1164 ASSERT_EQ(result.second, 0);
1165
1166 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1167 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1168 ASSERT_EQ(result.second, 0);
1169
1170 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1171 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1172 ASSERT_EQ(result.second, 2);
1173
1174 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1175 ASSERT_EQ(result.first, E_OK);
1176 ASSERT_EQ(result.second, 2);
1177
1178 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1179 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1180 ASSERT_EQ(result.second, 0);
1181
1182 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1183 ASSERT_NE(resultSet, nullptr);
1184 int rowCount;
1185 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1186 ASSERT_EQ(rowCount, 4);
1187 }
1188
1189 /* *
1190 * @tc.name: BatchInsertWithConflictResolution_003
1191 * @tc.desc: BatchInsertWithConflictResolution when violation the PRIMARY constraint.
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_003, TestSize.Level1)
1195 {
1196 std::string tableName = "BatchInsertWithConflictResolutionTest";
1197 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1198 auto res =
1199 store_->Execute("CREATE TABLE " + tableName + " (id TEXT PRIMARY KEY, name TEXT NOT NULL)");
1200 ASSERT_EQ(res.first, E_OK);
1201
1202 ValuesBuckets rows;
1203 for (int i = 0; i < 5; i++) {
1204 ValuesBucket row;
1205 row.Put("id", std::to_string(i));
1206 row.Put("name", "Jim");
1207 rows.Put(row);
1208 }
1209 Transaction::Row row;
1210 row.Put("id", "2");
1211 row.Put("name", "Jim");
1212 auto result = store_->Insert(tableName, row);
1213 ASSERT_EQ(result.first, E_OK);
1214 ASSERT_EQ(result.second, 1);
1215 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1216 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1217 ASSERT_EQ(result.second, 0);
1218
1219 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1220 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1221 ASSERT_EQ(result.second, 0);
1222
1223 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1224 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1225 ASSERT_EQ(result.second, 0);
1226
1227 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1228 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1229 ASSERT_EQ(result.second, 2);
1230
1231 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1232 ASSERT_EQ(result.first, E_OK);
1233 ASSERT_EQ(result.second, 2);
1234
1235 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1236 ASSERT_EQ(result.first, E_OK);
1237 ASSERT_EQ(result.second, 5);
1238
1239 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1240 ASSERT_NE(resultSet, nullptr);
1241 int rowCount;
1242 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1243 ASSERT_EQ(rowCount, 5);
1244 }
1245
1246 /* *
1247 * @tc.name: BatchInsertWithConflictResolution_004
1248 * @tc.desc: BatchInsertWithConflictResolution when violation the check constraint.
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_004, TestSize.Level1)
1252 {
1253 std::string tableName = "BatchInsertWithConflictResolutionTest";
1254 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1255 auto res = store_->Execute(
1256 "CREATE TABLE " + tableName + " (id INTEGER PRIMARY KEY CHECK (id >= 3 OR id <= 1), name TEXT NOT NULL)");
1257 ASSERT_EQ(res.first, E_OK);
1258
1259 ValuesBuckets rows;
1260 for (int i = 0; i < 5; i++) {
1261 ValuesBucket row;
1262 row.Put("id", i);
1263 row.Put("name", "Jim");
1264 rows.Put(row);
1265 }
1266 auto result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1267 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1268 ASSERT_EQ(result.second, 0);
1269
1270 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1271 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1272 ASSERT_EQ(result.second, 0);
1273
1274 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1275 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1276 ASSERT_EQ(result.second, 0);
1277
1278 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1279 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1280 ASSERT_EQ(result.second, 2);
1281
1282 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1283 ASSERT_EQ(result.first, E_OK);
1284 ASSERT_EQ(result.second, 2);
1285
1286 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1287 ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT);
1288 ASSERT_EQ(result.second, 0);
1289
1290 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1291 ASSERT_NE(resultSet, nullptr);
1292 int rowCount;
1293 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1294 ASSERT_EQ(rowCount, 4);
1295 }
1296
1297 /* *
1298 * @tc.name: BatchInsertWithConflictResolution_005
1299 * @tc.desc: BatchInsertWithConflictResolution when busy.
1300 * @tc.type: FUNC
1301 */
1302 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_005, TestSize.Level1)
1303 {
1304 std::string tableName = "BatchInsertWithConflictResolutionTest";
1305 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1306 auto res = store_->Execute(
1307 "CREATE TABLE " + tableName + " (id INTEGER PRIMARY KEY CHECK (id >= 3 OR id <= 1), name TEXT NOT NULL)");
1308 ASSERT_EQ(res.first, E_OK);
1309
1310 auto [code, transaction] = store_->CreateTransaction(Transaction::IMMEDIATE);
1311 ASSERT_EQ(code, E_OK);
1312 ASSERT_NE(transaction, nullptr);
1313
1314 ValuesBuckets rows;
1315 for (int i = 0; i < 5; i++) {
1316 ValuesBucket row;
1317 row.Put("id", i);
1318 row.Put("name", "Jim");
1319 rows.Put(row);
1320 }
1321 auto result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1322 ASSERT_EQ(result.first, E_SQLITE_BUSY);
1323 ASSERT_EQ(result.second, -1);
1324
1325 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1326 ASSERT_EQ(result.first, E_SQLITE_BUSY);
1327 ASSERT_EQ(result.second, -1);
1328
1329 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1330 ASSERT_EQ(result.first, E_SQLITE_BUSY);
1331 ASSERT_EQ(result.second, -1);
1332
1333 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1334 ASSERT_EQ(result.first, E_SQLITE_BUSY);
1335 ASSERT_EQ(result.second, -1);
1336
1337 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1338 ASSERT_EQ(result.first, E_SQLITE_BUSY);
1339 ASSERT_EQ(result.second, -1);
1340
1341 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1342 ASSERT_EQ(result.first, E_SQLITE_BUSY);
1343 ASSERT_EQ(result.second, -1);
1344
1345 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1346 ASSERT_NE(resultSet, nullptr);
1347 int rowCount;
1348 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1349 ASSERT_EQ(rowCount, 0);
1350 }
1351
1352 /* *
1353 * @tc.name: BatchInsertWithConflictResolution_006
1354 * @tc.desc: Normal BatchInsertWithConflictResolution.
1355 * @tc.type: FUNC
1356 */
1357 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_006, TestSize.Level1)
1358 {
1359 std::string tableName = "BatchInsertWithConflictResolutionTest";
1360 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1361 auto res =
1362 store_->Execute("CREATE TABLE " + tableName + " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL)");
1363 ASSERT_EQ(res.first, E_OK);
1364
1365 ValuesBuckets rows;
1366
1367 auto result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1368 ASSERT_EQ(result.first, E_OK);
1369 ASSERT_EQ(result.second, 0);
1370
1371 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1372 ASSERT_EQ(result.first, E_OK);
1373 ASSERT_EQ(result.second, 0);
1374
1375 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1376 ASSERT_EQ(result.first, E_OK);
1377 ASSERT_EQ(result.second, 0);
1378 for (int i = 0; i < 5; i++) {
1379 ValuesBucket row;
1380 row.Put("name", "Jim");
1381 rows.Put(row);
1382 }
1383
1384 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1385 ASSERT_EQ(result.first, E_OK);
1386 ASSERT_EQ(result.second, 5);
1387
1388 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1389 ASSERT_EQ(result.first, E_OK);
1390 ASSERT_EQ(result.second, 5);
1391
1392 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1393 ASSERT_EQ(result.first, E_OK);
1394 ASSERT_EQ(result.second, 5);
1395
1396 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1397 ASSERT_NE(resultSet, nullptr);
1398 int rowCount;
1399 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1400 ASSERT_EQ(rowCount, 15);
1401 }
1402
1403 /* *
1404 * @tc.name: BatchInsertWithConflictResolution_007
1405 * @tc.desc: over limit params BatchInsertWithConflictResolution.
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(RdbStoreImplTest, BatchInsertWithConflictResolution_007, TestSize.Level1)
1409 {
1410 std::string tableName = "BatchInsertWithConflictResolutionTest";
1411 store_->Execute("DROP TABLE IF EXISTS " + tableName);
1412 auto res =
1413 store_->Execute("CREATE TABLE " + tableName + " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL)");
1414 ASSERT_EQ(res.first, E_OK);
1415 //sqlite default max param number
1416 int32_t maxNumber = 32766;
1417 int32_t maxRows = maxNumber / 2 + 1;
1418 ValuesBuckets rows;
1419 for (int32_t i = 0; i < maxRows; i++) {
1420 ValuesBucket row;
1421 row.Put("id", i);
1422 row.Put("name", "Jim");
1423 rows.Put(row);
1424 }
1425 auto result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_NONE);
1426 ASSERT_EQ(result.first, E_INVALID_ARGS);
1427 ASSERT_EQ(result.second, -1);
1428
1429 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ROLLBACK);
1430 ASSERT_EQ(result.first, E_INVALID_ARGS);
1431 ASSERT_EQ(result.second, -1);
1432
1433 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_ABORT);
1434 ASSERT_EQ(result.first, E_INVALID_ARGS);
1435 ASSERT_EQ(result.second, -1);
1436
1437 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_FAIL);
1438 ASSERT_EQ(result.first, E_INVALID_ARGS);
1439 ASSERT_EQ(result.second, -1);
1440
1441 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_IGNORE);
1442 ASSERT_EQ(result.first, E_INVALID_ARGS);
1443 ASSERT_EQ(result.second, -1);
1444
1445 result = store_->BatchInsertWithConflictResolution(tableName, rows, ConflictResolution::ON_CONFLICT_REPLACE);
1446 ASSERT_EQ(result.first, E_INVALID_ARGS);
1447 ASSERT_EQ(result.second, -1);
1448
1449 std::shared_ptr<ResultSet> resultSet = store_->QueryByStep("SELECT * FROM " + tableName);
1450 ASSERT_NE(resultSet, nullptr);
1451 int rowCount;
1452 ASSERT_EQ(resultSet->GetRowCount(rowCount), E_OK);
1453 ASSERT_EQ(rowCount, 0);
1454 }
1455
1456 /**
1457 * @tc.name: RdbStore_Execute_001
1458 * @tc.desc: test RdbStore Execute
1459 * @tc.type: FUNC
1460 */
1461 HWTEST_F(RdbStoreImplTest, RdbStore_Execute_001, TestSize.Level1)
1462 {
1463 const std::string dbPath = RDB_TEST_PATH + "GetDatabase1.db";
1464 RdbStoreConfig config(dbPath);
1465 config.SetName("RdbStoreConfig_test.db");
1466 std::string bundleName = "com.ohos.config.TestSubUser";
1467 config.SetBundleName(bundleName);
1468 config.SetSubUser(100);
1469 auto subUser = config.GetSubUser();
1470 EXPECT_EQ(subUser, 100);
1471 int errCode = E_OK;
1472
1473 RdbStoreImplTestOpenCallback helper;
1474 std::shared_ptr<RdbStore> rdbStore = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1475 EXPECT_EQ(errCode, E_OK);
1476 ASSERT_NE(rdbStore, nullptr);
1477 rdbStore->ExecuteSql(CREATE_TABLE_TEST);
1478
1479 int64_t id;
1480 ValuesBucket values;
1481
1482 values.PutInt("id", 1);
1483 values.PutString("name", std::string("zhangsan"));
1484 values.PutInt("age", 18);
1485 values.PutDouble("salary", 100.5);
1486 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
1487 int ret = rdbStore->Insert(id, "test", values);
1488 EXPECT_EQ(ret, E_OK);
1489 EXPECT_EQ(1, id);
1490
1491 values.Clear();
1492 values.PutInt("id", 2);
1493 values.PutString("name", std::string("lisi"));
1494 values.PutInt("age", 19);
1495 values.PutDouble("salary", 200.5);
1496 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
1497 ret = rdbStore->Insert(id, "test", values);
1498 EXPECT_EQ(ret, E_OK);
1499 EXPECT_EQ(2, id);
1500
1501 int64_t count;
1502 ret = rdbStore->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
1503 EXPECT_EQ(ret, E_OK);
1504 EXPECT_EQ(count, 2);
1505
1506 ret = rdbStore->ExecuteSql("DELETE FROM test WHERE age = 18");
1507 EXPECT_EQ(ret, E_OK);
1508
1509 ret = rdbStore->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test where age = 19");
1510 EXPECT_EQ(ret, E_OK);
1511 EXPECT_EQ(count, 1);
1512
1513 ret = rdbStore->ExecuteSql("DELETE FROM test WHERE age = 19");
1514 EXPECT_EQ(ret, E_OK);
1515
1516 ret = RdbHelper::DeleteRdbStore(config);
1517 EXPECT_EQ(ret, E_OK);
1518 }