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 <gtest/gtest.h>
17
18 #include <string>
19
20 #include "common.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27
28 class RdbAttachTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 void QueryCheck1(std::shared_ptr<RdbStore> &store) const;
35 void QueryCheck2(std::shared_ptr<RdbStore> &store) const;
36 void DeleteCheck(std::shared_ptr<RdbStore> &store) const;
37 void UpdateCheck(std::shared_ptr<RdbStore> &store) const;
38 void InsertCheck(std::shared_ptr<RdbStore> &store) const;
39
40 static constexpr const char *MAIN_DATABASE_NAME = "/data/test/main.db";
41 static constexpr const char *ATTACHED_DATABASE_NAME = "/data/test/attached.db";
42 static constexpr const char *ENCRYPT_ATTACHED_DATABASE_NAME = "/data/test/encrypt_attached.db";
43 static constexpr int BUSY_TIMEOUT = 2;
44 };
45
46 class MainOpenCallback : public RdbOpenCallback {
47 public:
48 int OnCreate(RdbStore &store) override;
49 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
50 static const std::string CREATE_TABLE_TEST;
51 };
52
53 std::string const MainOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test1(id INTEGER PRIMARY KEY "
54 "AUTOINCREMENT, name TEXT NOT NULL)";
55
OnCreate(RdbStore & store)56 int MainOpenCallback::OnCreate(RdbStore &store)
57 {
58 return store.ExecuteSql(CREATE_TABLE_TEST);
59 }
60
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)61 int MainOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
62 {
63 return E_OK;
64 }
65
66 class AttachedOpenCallback : public RdbOpenCallback {
67 public:
68 int OnCreate(RdbStore &store) override;
69 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
70 static const std::string CREATE_TABLE_TEST;
71 };
72
73 std::string const AttachedOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test2(id INTEGER PRIMARY KEY "
74 "AUTOINCREMENT, name TEXT NOT NULL)";
75
OnCreate(RdbStore & store)76 int AttachedOpenCallback::OnCreate(RdbStore &store)
77 {
78 return store.ExecuteSql(CREATE_TABLE_TEST);
79 }
80
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)81 int AttachedOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
82 {
83 return E_OK;
84 }
85
SetUpTestCase(void)86 void RdbAttachTest::SetUpTestCase(void)
87 {
88 RdbStoreConfig attachedConfig(RdbAttachTest::ATTACHED_DATABASE_NAME);
89 AttachedOpenCallback attachedHelper;
90 int errCode = E_OK;
91 std::shared_ptr<RdbStore> attachedStore = RdbHelper::GetRdbStore(attachedConfig, 1, attachedHelper, errCode);
92 EXPECT_NE(attachedStore, nullptr);
93 }
94
TearDownTestCase(void)95 void RdbAttachTest::TearDownTestCase(void)
96 {
97 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
98 RdbHelper::DeleteRdbStore(ATTACHED_DATABASE_NAME);
99 }
100
SetUp(void)101 void RdbAttachTest::SetUp(void)
102 {
103 }
104
TearDown(void)105 void RdbAttachTest::TearDown(void)
106 {
107 RdbHelper::ClearCache();
108 }
109
110 /**
111 * @tc.name: RdbStore_Attach_001
112 * @tc.desc: test attach, attach is not supported in wal mode
113 * @tc.type: FUNC
114 */
115 HWTEST_F(RdbAttachTest, RdbStore_Attach_001, TestSize.Level1)
116 {
117 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
118 MainOpenCallback helper;
119 int errCode = E_OK;
120 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
121 EXPECT_NE(store, nullptr);
122
123 int ret = store->ExecuteSql("ATTACH '" + std::string(ATTACHED_DATABASE_NAME) + "' as attached");
124 EXPECT_EQ(ret, E_NOT_SUPPORTED_ATTACH_IN_WAL_MODE);
125 }
126
127 /**
128 * @tc.name: RdbStore_Attach_002
129 * @tc.desc: test RdbStore attach
130 * @tc.type: FUNC
131 */
132 HWTEST_F(RdbAttachTest, RdbStore_Attach_002, TestSize.Level1)
133 {
134 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
135 config.SetJournalMode(JournalMode::MODE_TRUNCATE);
136 MainOpenCallback helper;
137 int errCode = E_OK;
138 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
139 EXPECT_NE(store, nullptr);
140
141 int ret = store->ExecuteSql("ATTACH DATABASE '" + std::string(ATTACHED_DATABASE_NAME) + "' as 'attached'");
142 EXPECT_EQ(ret, E_OK);
143
144 InsertCheck(store);
145
146 QueryCheck1(store);
147
148 ret = store->ExecuteSql("DETACH DATABASE 'attached'");
149 EXPECT_EQ(ret, E_OK);
150
151 QueryCheck2(store);
152
153 ret = store->ExecuteSql("attach database '" + std::string(ATTACHED_DATABASE_NAME) + "' as 'attached'");
154 EXPECT_EQ(ret, E_OK);
155
156 ret = store->ExecuteSql("detach database 'attached'");
157 EXPECT_EQ(ret, E_OK);
158 }
159
160 /**
161 * @tc.name: RdbStore_Attach_003
162 * @tc.desc: Abnormal testCase for Attach
163 * @tc.type: FUNC
164 */
165 HWTEST_F(RdbAttachTest, RdbStore_Attach_003, TestSize.Level2)
166 {
167 const std::string attachedName = "attached";
168 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
169 MainOpenCallback helper;
170 int errCode = E_OK;
171
172 // journal mode is wal
173 std::shared_ptr<RdbStore> store1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
174 EXPECT_NE(nullptr, store1);
175 EXPECT_EQ(E_OK, errCode);
176 RdbStoreConfig attachedConfig(RdbAttachTest::ATTACHED_DATABASE_NAME);
177 auto ret = store1->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
178 EXPECT_EQ(E_OK, ret.first);
179 EXPECT_EQ(1, ret.second);
180 QueryCheck1(store1);
181 // use the same attachedName to attach again
182 ret = store1->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
183 EXPECT_EQ(E_ATTACHED_DATABASE_EXIST, ret.first);
184
185 ret = store1->Detach(attachedName);
186 EXPECT_EQ(E_OK, ret.first);
187 EXPECT_EQ(0, ret.second);
188 QueryCheck2(store1);
189 }
190
191 /**
192 * @tc.name: RdbStore_Attach_004
193 * @tc.desc: Abnormal testCase for Attach with wrong path
194 * @tc.type: FUNC
195 */
196 HWTEST_F(RdbAttachTest, RdbStore_Attach_004, TestSize.Level2)
197 {
198 const std::string attachedName = "attached";
199 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
200 MainOpenCallback helper;
201 int errCode = E_OK;
202
203 // journal mode is wal
204 std::shared_ptr<RdbStore> store1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
205 EXPECT_NE(nullptr, store1);
206 EXPECT_EQ(E_OK, errCode);
207 RdbStoreConfig attachedConfig("/wrong/path");
208 auto ret = store1->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
209 EXPECT_EQ(E_INVALID_FILE_PATH, ret.first);
210 }
211
212 /**
213 * @tc.name: RdbStore_Attach_005
214 * @tc.desc: Abnormal testCase for Attach encrypted database
215 * @tc.type: FUNC
216 */
217 HWTEST_F(RdbAttachTest, RdbStore_Attach_005, TestSize.Level2)
218 {
219 int errCode = E_OK;
220 AttachedOpenCallback attachedHelper;
221 RdbStoreConfig encryptAttachedConfig(RdbAttachTest::ENCRYPT_ATTACHED_DATABASE_NAME);
222 encryptAttachedConfig.SetEncryptStatus(true);
223 std::shared_ptr<RdbStore> encryptAttachedStore =
224 RdbHelper::GetRdbStore(encryptAttachedConfig, 1, attachedHelper, errCode);
225 EXPECT_NE(encryptAttachedStore, nullptr);
226
227 encryptAttachedStore = nullptr;
228 const std::string attachedName = "attached";
229 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
230 MainOpenCallback helper;
231
232 // journal mode is wal
233 std::shared_ptr<RdbStore> store1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
234 EXPECT_NE(nullptr, store1);
235 EXPECT_EQ(E_OK, errCode);
236 auto ret = store1->Attach(encryptAttachedConfig, attachedName, BUSY_TIMEOUT);
237 EXPECT_EQ(E_OK, ret.first);
238 EXPECT_EQ(1, ret.second);
239
240 int64_t id;
241 ValuesBucket values;
242 values.PutInt("id", 1);
243 values.PutString("name", std::string("lisi"));
244 int res = store1->Insert(id, "test2", values);
245 EXPECT_EQ(res, E_OK);
246 EXPECT_EQ(id, 1);
247 QueryCheck1(store1);
248
249 ret = store1->Detach(attachedName);
250 EXPECT_EQ(E_OK, ret.first);
251 EXPECT_EQ(0, ret.second);
252 QueryCheck2(store1);
253 RdbHelper::DeleteRdbStore(RdbAttachTest::ENCRYPT_ATTACHED_DATABASE_NAME);
254 }
255
256 /**
257 * @tc.name: RdbStore_Attach_006
258 * @tc.desc: Abnormal testCase for Attach
259 * @tc.type: FUNC
260 */
261 HWTEST_F(RdbAttachTest, RdbStore_Attach_006, TestSize.Level2)
262 {
263 const std::string attachedName = "attached";
264 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
265 MainOpenCallback helper;
266 int errCode = E_OK;
267
268 // journal mode is wal
269 std::shared_ptr<RdbStore> store1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
270 EXPECT_NE(nullptr, store1);
271 EXPECT_EQ(E_OK, errCode);
272 RdbStoreConfig attachedConfig(RdbAttachTest::ATTACHED_DATABASE_NAME);
273 auto ret = store1->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
274 EXPECT_EQ(E_OK, ret.first);
275 EXPECT_EQ(1, ret.second);
276
277 UpdateCheck(store1);
278 DeleteCheck(store1);
279
280 ret = store1->Detach(attachedName);
281 EXPECT_EQ(E_OK, ret.first);
282 EXPECT_EQ(0, ret.second);
283 }
284
285 /**
286 * @tc.name: RdbStore_Attach_007
287 * @tc.desc: normal testCase for Attach with memoryDb
288 * @tc.type: FUNC
289 */
290 HWTEST_F(RdbAttachTest, RdbStore_Attach_007, TestSize.Level2)
291 {
292 const std::string attachedName = "attached";
293 RdbStoreConfig config(RdbAttachTest::MAIN_DATABASE_NAME);
294 MainOpenCallback helper;
295 int errCode = E_OK;
296 std::shared_ptr<RdbStore> walDb = RdbHelper::GetRdbStore(config, 1, helper, errCode);
297 ASSERT_NE(nullptr, walDb);
298 ASSERT_EQ(E_OK, errCode);
299
300 RdbStoreConfig attachedConfig("/data/test/memoryAttachTest007.db");
301 attachedConfig.SetStorageMode(StorageMode::MODE_MEMORY);
302 std::shared_ptr<RdbStore> memDb = RdbHelper::GetRdbStore(attachedConfig, 1, helper, errCode);
303
304 std::string sql = "CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY "
305 "AUTOINCREMENT, name TEXT NOT NULL)";
306 auto code = memDb->ExecuteSql(sql);
307 ASSERT_EQ(E_OK, code);
308
309 ValueObject val;
310 std::tie(code, val) = memDb->Execute("insert into test (id, name) values(?,?)", { 1, "memDbName" });
311 ASSERT_EQ(E_OK, code);
312
313 auto ret = walDb->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
314 ASSERT_EQ(E_OK, ret.first);
315 ASSERT_EQ(1, ret.second);
316
317 auto result = walDb->QuerySql("select * from attached.test");
318 ASSERT_NE(result, nullptr);
319 int count = -1;
320 ASSERT_EQ(E_OK, result->GetRowCount(count));
321 EXPECT_EQ(count, 1);
322 ASSERT_EQ(E_OK, result->GoToFirstRow());
323
324 int index = -1;
325 ASSERT_EQ(E_OK, result->GetColumnIndex("name", index));
326 std::string name;
327 ASSERT_EQ(E_OK, result->GetString(index, name));
328 EXPECT_EQ(name, "memDbName");
329 result->Close();
330
331 ret = walDb->Detach(attachedName);
332 EXPECT_EQ(E_OK, ret.first);
333 EXPECT_EQ(0, ret.second);
334 }
335
336 /**
337 * @tc.name: RdbStore_Attach_008
338 * @tc.desc: normal testCase for memoryDb attach with memoryDb
339 * @tc.type: FUNC
340 */
341 HWTEST_F(RdbAttachTest, RdbStore_Attach_008, TestSize.Level2)
342 {
343 const std::string attachedName = "attached";
344 RdbStoreConfig config("/data/test/memoryAttachMain008.db");
345 config.SetStorageMode(StorageMode::MODE_MEMORY);
346 MainOpenCallback helper;
347 int errCode = E_OK;
348 std::shared_ptr<RdbStore> mainMemDb = RdbHelper::GetRdbStore(config, 1, helper, errCode);
349 ASSERT_NE(nullptr, mainMemDb);
350 ASSERT_EQ(E_OK, errCode);
351
352 RdbStoreConfig attachedConfig("/data/test/memoryAttachTest008.db");
353 attachedConfig.SetStorageMode(StorageMode::MODE_MEMORY);
354 std::shared_ptr<RdbStore> memDb = RdbHelper::GetRdbStore(attachedConfig, 1, helper, errCode);
355
356 std::string sql = "CREATE TABLE IF NOT EXISTS test1(id INTEGER PRIMARY KEY "
357 "AUTOINCREMENT, name TEXT NOT NULL)";
358 auto code = memDb->ExecuteSql(sql);
359 ASSERT_EQ(E_OK, code);
360
361 auto ret = mainMemDb->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
362 ASSERT_EQ(E_OK, ret.first);
363 ASSERT_EQ(1, ret.second);
364
365 ValueObject val;
366 std::tie(code, val) = mainMemDb->Execute("insert into attached.test1 (id, name) values(?,?)", { 1, "memDbName" });
367 ASSERT_EQ(E_OK, ret.first);
368 auto result = mainMemDb->QuerySql("select * from attached.test1;");
369 ASSERT_NE(result, nullptr);
370 int count = -1;
371 ASSERT_EQ(E_OK, result->GetRowCount(count));
372 EXPECT_EQ(count, 1);
373 ASSERT_EQ(E_OK, result->GoToFirstRow());
374
375 int index = -1;
376 ASSERT_EQ(E_OK, result->GetColumnIndex("name", index));
377 std::string name;
378 ASSERT_EQ(E_OK, result->GetString(index, name));
379 EXPECT_EQ(name, "memDbName");
380 result->Close();
381
382 ret = mainMemDb->Detach(attachedName);
383 EXPECT_EQ(E_OK, ret.first);
384 EXPECT_EQ(0, ret.second);
385 }
386
387 /**
388 * @tc.name: RdbStore_Attach_009
389 * @tc.desc: normal testCase for memoryDb attach with walDb
390 * @tc.type: FUNC
391 */
392 HWTEST_F(RdbAttachTest, RdbStore_Attach_009, TestSize.Level2)
393 {
394 const std::string attachedName = "attached";
395 RdbStoreConfig config("/data/test/memoryAttachMain009.db");
396 config.SetStorageMode(StorageMode::MODE_MEMORY);
397 MainOpenCallback helper;
398 int errCode = E_OK;
399 std::shared_ptr<RdbStore> mainMemDb = RdbHelper::GetRdbStore(config, 1, helper, errCode);
400 ASSERT_NE(nullptr, mainMemDb);
401 ASSERT_EQ(E_OK, errCode);
402
403 RdbStoreConfig attachedConfig("/data/test/AttachTest009.db");
404 std::shared_ptr<RdbStore> walDb = RdbHelper::GetRdbStore(attachedConfig, 1, helper, errCode);
405
406 std::string sql = "CREATE TABLE IF NOT EXISTS test1(id INTEGER PRIMARY KEY "
407 "AUTOINCREMENT, name TEXT NOT NULL)";
408 auto code = walDb->ExecuteSql(sql);
409 ASSERT_EQ(E_OK, code);
410
411 auto ret = mainMemDb->Attach(attachedConfig, attachedName, BUSY_TIMEOUT);
412 ASSERT_EQ(E_OK, ret.first);
413 ASSERT_EQ(1, ret.second);
414
415 ValueObject val;
416 std::tie(code, val) = mainMemDb->Execute("insert into attached.test1 (id, name) values(?,?)", { 1, "memDbName" });
417 ASSERT_EQ(E_OK, ret.first);
418 auto result = mainMemDb->QuerySql("select * from attached.test1;");
419 ASSERT_NE(result, nullptr);
420 int count = -1;
421 ASSERT_EQ(E_OK, result->GetRowCount(count));
422 EXPECT_EQ(count, 1);
423 ASSERT_EQ(E_OK, result->GoToFirstRow());
424
425 int index = -1;
426 ASSERT_EQ(E_OK, result->GetColumnIndex("name", index));
427 std::string name;
428 ASSERT_EQ(E_OK, result->GetString(index, name));
429 EXPECT_EQ(name, "memDbName");
430 result->Close();
431
432 ret = mainMemDb->Detach(attachedName);
433 EXPECT_EQ(E_OK, ret.first);
434 EXPECT_EQ(0, ret.second);
435 }
436
QueryCheck1(std::shared_ptr<RdbStore> & store) const437 void RdbAttachTest::QueryCheck1(std::shared_ptr<RdbStore> &store) const
438 {
439 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1");
440 EXPECT_NE(resultSet, nullptr);
441 int ret = resultSet->GoToNextRow();
442 EXPECT_EQ(ret, E_OK);
443 int columnIndex;
444 int intVal;
445 ret = resultSet->GetColumnIndex("id", columnIndex);
446 EXPECT_EQ(ret, E_OK);
447 ret = resultSet->GetInt(columnIndex, intVal);
448 EXPECT_EQ(ret, E_OK);
449 EXPECT_EQ(intVal, 1);
450 std::string strVal;
451 ret = resultSet->GetColumnIndex("name", columnIndex);
452 EXPECT_EQ(ret, E_OK);
453 ret = resultSet->GetString(columnIndex, strVal);
454 EXPECT_EQ(ret, E_OK);
455 EXPECT_EQ(strVal, "zhangsan");
456
457 resultSet = store->QuerySql("SELECT * FROM test2");
458 EXPECT_NE(resultSet, nullptr);
459 ret = resultSet->GoToNextRow();
460 EXPECT_EQ(ret, E_OK);
461 ret = resultSet->GetColumnIndex("id", columnIndex);
462 EXPECT_EQ(ret, E_OK);
463 ret = resultSet->GetInt(columnIndex, intVal);
464 EXPECT_EQ(ret, E_OK);
465 EXPECT_EQ(intVal, 1);
466 ret = resultSet->GetColumnIndex("name", columnIndex);
467 EXPECT_EQ(ret, E_OK);
468 ret = resultSet->GetString(columnIndex, strVal);
469 EXPECT_EQ(ret, E_OK);
470 EXPECT_EQ(strVal, "lisi");
471 }
472
QueryCheck2(std::shared_ptr<RdbStore> & store) const473 void RdbAttachTest::QueryCheck2(std::shared_ptr<RdbStore> &store) const
474 {
475 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1");
476 EXPECT_NE(resultSet, nullptr);
477 int ret = resultSet->GoToNextRow();
478 EXPECT_EQ(ret, E_OK);
479 int columnIndex;
480 int intVal;
481 ret = resultSet->GetColumnIndex("id", columnIndex);
482 EXPECT_EQ(ret, E_OK);
483 ret = resultSet->GetInt(columnIndex, intVal);
484 EXPECT_EQ(ret, E_OK);
485 EXPECT_EQ(intVal, 1);
486 std::string strVal;
487 ret = resultSet->GetColumnIndex("name", columnIndex);
488 EXPECT_EQ(ret, E_OK);
489 ret = resultSet->GetString(columnIndex, strVal);
490 EXPECT_EQ(ret, E_OK);
491 EXPECT_EQ(strVal, "zhangsan");
492
493 // detached, no table test2
494 resultSet = store->QuerySql("SELECT * FROM test2");
495 EXPECT_NE(resultSet, nullptr);
496 }
497
DeleteCheck(std::shared_ptr<RdbStore> & store) const498 void RdbAttachTest::DeleteCheck(std::shared_ptr<RdbStore> &store) const
499 {
500 int changedRows = 0;
501 AbsRdbPredicates predicates("test1");
502 predicates.EqualTo("id", 1);
503 int ret = store->Delete(changedRows, predicates);
504 EXPECT_EQ(ret, E_OK);
505 EXPECT_EQ(changedRows, 1);
506
507 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1 where name = 'lisi_update1'");
508 EXPECT_NE(resultSet, nullptr);
509 int count = 0;
510 resultSet->GetRowCount(count);
511 EXPECT_EQ(0, count);
512
513 int changedRows2 = 0;
514 AbsRdbPredicates predicates2("test2");
515 predicates2.EqualTo("id", 1);
516 ret = store->Delete(changedRows2, predicates2);
517 EXPECT_EQ(ret, E_OK);
518 EXPECT_EQ(changedRows2, 1);
519
520 std::shared_ptr<ResultSet> resultSet2 = store->QuerySql("SELECT * FROM test2 where name = 'lisi_update2'");
521 EXPECT_NE(resultSet2, nullptr);
522 int count2 = 0;
523 resultSet2->GetRowCount(count2);
524 EXPECT_EQ(0, count2);
525 }
526
UpdateCheck(std::shared_ptr<RdbStore> & store) const527 void RdbAttachTest::UpdateCheck(std::shared_ptr<RdbStore> &store) const
528 {
529 int changedRows = 0;
530 ValuesBucket values;
531 values.PutString("name", std::string("lisi_update1"));
532 AbsRdbPredicates predicates("test1");
533 predicates.EqualTo("id", 1);
534 int ret = store->Update(changedRows, values, predicates);
535 EXPECT_EQ(ret, E_OK);
536 EXPECT_EQ(changedRows, 1);
537
538 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1 where name = 'lisi_update1'");
539 EXPECT_NE(resultSet, nullptr);
540 int count = 0;
541 resultSet->GetRowCount(count);
542 EXPECT_EQ(1, count);
543
544 values.Clear();
545 values.PutString("name", std::string("lisi_update2"));
546 AbsRdbPredicates predicates2("test2");
547 predicates2.EqualTo("id", 1);
548 int changedRows2 = 0;
549 ret = store->Update(changedRows2, values, predicates2);
550 EXPECT_EQ(ret, E_OK);
551 EXPECT_EQ(changedRows2, 1);
552
553 std::shared_ptr<ResultSet> resultSet2 = store->QuerySql("SELECT * FROM test2 where name = 'lisi_update2'");
554 EXPECT_NE(resultSet2, nullptr);
555 int count2 = 0;
556 resultSet2->GetRowCount(count2);
557 EXPECT_EQ(1, count2);
558 }
559
InsertCheck(std::shared_ptr<RdbStore> & store) const560 void RdbAttachTest::InsertCheck(std::shared_ptr<RdbStore> &store) const
561 {
562 int64_t id;
563 ValuesBucket values;
564 values.PutInt("id", 1);
565 values.PutString("name", std::string("zhangsan"));
566 int ret = store->Insert(id, "test1", values);
567 EXPECT_EQ(ret, E_OK);
568 EXPECT_EQ(id, 1);
569
570 values.Clear();
571 values.PutInt("id", 1);
572 values.PutString("name", std::string("lisi"));
573 ret = store->Insert(id, "test2", values);
574 EXPECT_EQ(ret, E_OK);
575 EXPECT_EQ(id, 1);
576 }
577