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_common.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25 #include "sqlite_sql_builder.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29 namespace OHOS::RdbStoreUpdateTest {
30 struct RdbTestParam {
31 std::shared_ptr<RdbStore> store;
operator std::shared_ptr<RdbStore>OHOS::RdbStoreUpdateTest::RdbTestParam32 operator std::shared_ptr<RdbStore>()
33 {
34 return store;
35 }
36 };
37 static RdbTestParam g_store;
38 static RdbTestParam g_memDb;
39
40 class RdbStoreUpdateTest : public testing::TestWithParam<RdbTestParam *> {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 static void ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet, const RowData &expect);
45 void SetUp();
46 void TearDown();
47 std::shared_ptr<RdbStore> store_;
48
49 static const std::string DATABASE_NAME;
50 };
51
52 const std::string RdbStoreUpdateTest::DATABASE_NAME = RDB_TEST_PATH + "update_test.db";
53
54 class UpdateTestOpenCallback : public RdbOpenCallback {
55 public:
56 int OnCreate(RdbStore &store) override;
57 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
58 };
59 constexpr const char *CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test ("
60 "id INTEGER PRIMARY KEY AUTOINCREMENT, "
61 "name TEXT UNIQUE, "
62 "age INTEGER, "
63 "salary REAL, "
64 "blobType BLOB, "
65 "assetType ASSET, "
66 "assetsType ASSETS)";
OnCreate(RdbStore & store)67 int UpdateTestOpenCallback::OnCreate(RdbStore &store)
68 {
69 return store.ExecuteSql(CREATE_TABLE_TEST);
70 }
71
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)72 int UpdateTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
73 {
74 return E_OK;
75 }
76
SetUpTestCase(void)77 void RdbStoreUpdateTest::SetUpTestCase(void)
78 {
79 int errCode = E_OK;
80 RdbHelper::DeleteRdbStore(DATABASE_NAME);
81 RdbStoreConfig config(RdbStoreUpdateTest::DATABASE_NAME);
82 UpdateTestOpenCallback helper;
83 g_store.store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
84 ASSERT_NE(g_store.store, nullptr);
85
86 config.SetStorageMode(StorageMode::MODE_MEMORY);
87 g_memDb.store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
88 ASSERT_NE(g_memDb.store, nullptr);
89 }
90
TearDownTestCase(void)91 void RdbStoreUpdateTest::TearDownTestCase(void)
92 {
93 RdbStoreConfig config(RdbStoreUpdateTest::DATABASE_NAME);
94 RdbHelper::DeleteRdbStore(config);
95 config.SetStorageMode(StorageMode::MODE_MEMORY);
96 RdbHelper::DeleteRdbStore(config);
97 }
98
SetUp(void)99 void RdbStoreUpdateTest::SetUp(void)
100 {
101 store_ = *GetParam();
102 store_->ExecuteSql("DELETE FROM test");
103 }
104
TearDown(void)105 void RdbStoreUpdateTest::TearDown(void)
106 {
107 RdbHelper::ClearCache();
108 }
109
110 /**
111 * @tc.name: RdbStore_Update_001
112 * @tc.desc: test RdbStore update, select id and update one row
113 * @tc.type: FUNC
114 */
115 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_001, TestSize.Level1)
116 {
117 std::shared_ptr<RdbStore> store = *GetParam();
118
119 ValuesBucket values;
120 int changedRows;
121 int64_t id;
122
123 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
124 EXPECT_EQ(ret, E_OK);
125 EXPECT_EQ(1, id);
126
127 values.Clear();
128 values.PutInt("id", 2);
129 values.PutString("name", std::string("lisi"));
130 values.PutInt("age", 20);
131 values.PutDouble("salary", 200.5);
132 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
133 ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
134 EXPECT_EQ(ret, E_OK);
135 EXPECT_EQ(1, changedRows);
136
137 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
138 EXPECT_NE(resultSet, nullptr);
139
140 ret = resultSet->GoToFirstRow();
141 EXPECT_EQ(ret, E_OK);
142 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
143
144 ret = resultSet->GoToNextRow();
145 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
146
147 ret = resultSet->Close();
148 EXPECT_EQ(ret, E_OK);
149 }
150
151 /**
152 * @tc.name: RdbStore_Update_002
153 * @tc.desc: test RdbStore update, no select and update all rows
154 * @tc.type: FUNC
155 */
156 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_002, TestSize.Level1)
157 {
158 std::shared_ptr<RdbStore> store = *GetParam();
159
160 int64_t id;
161 ValuesBucket values;
162 int changedRows;
163
164 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
165 EXPECT_EQ(ret, E_OK);
166 EXPECT_EQ(1, id);
167
168 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
169 EXPECT_EQ(ret, E_OK);
170 EXPECT_EQ(2, id);
171
172 values.Clear();
173 values.PutDouble("salary", 300.5);
174 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
175 ret = store->Update(changedRows, "test", values);
176 EXPECT_EQ(ret, E_OK);
177 EXPECT_EQ(2, changedRows);
178
179 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
180 EXPECT_NE(resultSet, nullptr);
181
182 ret = resultSet->GoToNextRow();
183 EXPECT_EQ(ret, E_OK);
184 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
185
186 ret = resultSet->GoToNextRow();
187 EXPECT_EQ(ret, E_OK);
188 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
189
190 ret = resultSet->GoToNextRow();
191 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
192
193 ret = resultSet->Close();
194 EXPECT_EQ(ret, E_OK);
195 }
196
197 /**
198 * @tc.name: RdbStore_Update_003
199 * @tc.desc: test RdbStore update
200 * @tc.type: FUNC
201 */
202 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_003, TestSize.Level1)
203 {
204 std::shared_ptr<RdbStore> store = *GetParam();
205
206 int changedRows;
207 ValuesBucket values;
208 values.PutInt("id", 1);
209 values.PutString("name", std::string("zhangsan"));
210 values.PutInt("age", 18);
211 values.PutDouble("salary", 100.5);
212 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
213 int ret = store->Update(changedRows, "", values, "", std::vector<std::string>()); // empty table name
214 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
215
216 ret = store->Update(changedRows, "wrongTable", values, "", std::vector<std::string>()); // no such table
217 EXPECT_EQ(ret, E_SQLITE_ERROR);
218 }
219
220 /**
221 * @tc.name: RdbStore_Update_004
222 * @tc.desc: test RdbStore insert
223 * @tc.type: FUNC
224 */
225 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_004, TestSize.Level1)
226 {
227 std::shared_ptr<RdbStore> store = *GetParam();
228
229 int changedRows;
230 ValuesBucket emptyBucket;
231 int ret = store->Update(changedRows, "test", emptyBucket);
232 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
233
234 ValuesBucket values;
235 values.PutInt("id", 1);
236 values.PutString("name", std::string("zhangsan"));
237 values.PutInt("age", 18);
238 values.PutDouble("wrongColumn", 100.5); // no such column
239 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
240 ret = store->Update(changedRows, "test", values, "", std::vector<std::string>());
241 EXPECT_EQ(ret, E_SQLITE_ERROR);
242 }
243
244 /**
245 * @tc.name: RdbStore_Update_005
246 * @tc.desc: test RdbStore insert
247 * @tc.type: FUNC
248 */
249 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_005, TestSize.Level1)
250 {
251 std::shared_ptr<RdbStore> store = *GetParam();
252
253 ValuesBucket values;
254 int changedRows;
255 int64_t id;
256
257 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
258 EXPECT_EQ(ret, E_OK);
259 EXPECT_EQ(1, id);
260
261 ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
262 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
263 }
264
265 /**
266 * @tc.name: RdbStore_Update_006
267 * @tc.desc: test RdbStore insert
268 * @tc.type: FUNC
269 */
270 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_006, TestSize.Level1)
271 {
272 std::shared_ptr<RdbStore> store = *GetParam();
273
274 ValuesBucket values;
275 int changedRows;
276 int64_t id;
277
278 values.Clear();
279 values.PutString("id", "2");
280 values.PutString("name", std::string("lisi"));
281 values.PutInt("age", 20);
282 values.PutDouble("salary", 200.5);
283 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
284 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
285 EXPECT_EQ(ret, E_OK);
286 EXPECT_EQ(1, id);
287
288 ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
289 EXPECT_EQ(ret, E_OK);
290 EXPECT_EQ(1, changedRows);
291
292 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
293 EXPECT_NE(resultSet, nullptr);
294
295 ret = resultSet->GoToFirstRow();
296 EXPECT_EQ(ret, E_OK);
297 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
298
299 ret = resultSet->GoToNextRow();
300 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
301
302 ret = resultSet->Close();
303 EXPECT_EQ(ret, E_OK);
304 }
305
306 /**
307 * @tc.name: RdbStore_Update_007
308 * @tc.desc: test RdbStore update asset
309 * @tc.type: FUNC
310 */
311 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_007, TestSize.Level1)
312 {
313 std::shared_ptr<RdbStore> store = *GetParam();
314 ValuesBucket values;
315 AssetValue value{ .version = 1, .name = "123", .uri = "your test path", .createTime = "13", .modifyTime = "13" };
316 int changedRows;
317 int64_t id;
318 values.PutNull("assetType");
319 int ret = store->Insert(id, "test", values);
320 EXPECT_EQ(ret, E_OK);
321 EXPECT_EQ(3, id);
322 values.Clear();
323 values.Put("assetType", value);
324 ret = store->Update(changedRows, "test", values);
325 EXPECT_EQ(ret, E_OK);
326 EXPECT_EQ(1, changedRows);
327 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
328 EXPECT_NE(resultSet, nullptr);
329
330 ret = resultSet->GoToFirstRow();
331 EXPECT_EQ(ret, E_OK);
332
333 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ .id = 3,
334 .asset{ .version = 1,
335 .status = AssetValue::STATUS_INSERT,
336 .name = "123",
337 .uri = "your test path",
338 .createTime = "13",
339 .modifyTime = "13" } });
340 ret = resultSet->Close();
341 EXPECT_EQ(ret, E_OK);
342 }
343
344 /**
345 * @tc.name: RdbStore_Update_008
346 * @tc.desc: test RdbStore update asset
347 * @tc.type: FUNC
348 */
349 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_008, TestSize.Level1)
350 {
351 std::shared_ptr<RdbStore> store = *GetParam();
352 ValuesBucket values;
353 AssetValue valueDef{
354 .version = 0,
355 .name = "123",
356 .uri = "my test path",
357 .createTime = "12",
358 .modifyTime = "12",
359 };
360 AssetValue value{ .version = 2, .name = "456", .uri = "your test path", .createTime = "15", .modifyTime = "15" };
361 int changedRows;
362 int64_t id;
363 values.Put("assetType", valueDef);
364 int ret = store->Insert(id, "test", values);
365 EXPECT_EQ(ret, E_OK);
366 EXPECT_EQ(4, id);
367 values.Clear();
368 values.Put("assetType", value);
369 ret = store->Update(changedRows, "test", values);
370 EXPECT_EQ(ret, E_OK);
371 EXPECT_EQ(1, changedRows);
372 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
373 EXPECT_NE(resultSet, nullptr);
374
375 ret = resultSet->GoToFirstRow();
376 EXPECT_EQ(ret, E_OK);
377 RdbStoreUpdateTest::ExpectValue(resultSet,
378 RowData{ .id = 4,
379 .asset{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" } });
380 ret = resultSet->Close();
381 EXPECT_EQ(ret, E_OK);
382 }
383
384 /**
385 * @tc.name: RdbStore_Update_009
386 * @tc.desc: test RdbStore update asset
387 * @tc.type: FUNC
388 */
389 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_009, TestSize.Level1)
390 {
391 std::shared_ptr<RdbStore> store = *GetParam();
392 ValuesBucket values;
393 AssetValue valueDef{ .version = 0,
394 .status = AssetValue::STATUS_NORMAL,
395 .name = "123",
396 .uri = "my test path",
397 .createTime = "12",
398 .modifyTime = "12",
399 .size = "543",
400 .hash = "321" };
401 AssetValue value{ .name = "123" };
402 value.status = AssetValue::STATUS_DELETE;
403 int changedRows;
404 int64_t id;
405 values.Put("assetType", valueDef);
406 int ret = store->Insert(id, "test", values);
407 EXPECT_EQ(ret, E_OK);
408 EXPECT_EQ(5, id);
409 values.Clear();
410 values.Put("assetType", value);
411 ret = store->Update(changedRows, "test", values);
412 EXPECT_EQ(ret, E_OK);
413 EXPECT_EQ(1, changedRows);
414 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
415 EXPECT_NE(resultSet, nullptr);
416 ret = resultSet->GoToFirstRow();
417 EXPECT_EQ(ret, E_OK);
418 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ .id = 5,
419 .asset{ .version = 0,
420 .status = AssetValue::Status::STATUS_DELETE,
421 .name = "123",
422 .uri = "my test path",
423 .createTime = "12",
424 .modifyTime = "",
425 .size = "",
426 .hash = "" } });
427 ret = resultSet->Close();
428 EXPECT_EQ(ret, E_OK);
429 }
430
431 /**
432 * @tc.name: RdbStore_Update_010
433 * @tc.desc: test RdbStore update assets
434 * @tc.type: FUNC
435 */
436 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_010, TestSize.Level1)
437 {
438 std::shared_ptr<RdbStore> store = *GetParam();
439 ValuesBucket values;
440 std::vector<AssetValue> assetsDef{
441 { .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" }
442 };
443 AssetValue value1{ .version = 1, .name = "123", .uri = "your test path", .createTime = "13", .modifyTime = "13" };
444 AssetValue value2{ .version = 2, .name = "123", .uri = "your test path", .createTime = "14", .modifyTime = "14" };
445 AssetValue value3{ .version = 3, .name = "456", .uri = "your test path", .createTime = "15", .modifyTime = "15" };
446 auto assets = ValueObject::Assets({ value1, value2, value3 });
447 int changedRows;
448 int64_t id;
449 values.Put("assetsType", assetsDef);
450 int ret = store->Insert(id, "test", values);
451 EXPECT_EQ(ret, E_OK);
452 EXPECT_EQ(6, id);
453 values.Clear();
454 values.Put("assetsType", assets);
455
456 ret = store->Update(changedRows, "test", values);
457 EXPECT_EQ(ret, E_OK);
458 EXPECT_EQ(1, changedRows);
459 }
460
461 /**
462 * @tc.name: RdbStore_UpdateWithConflictResolution_001
463 * @tc.desc: test RdbStore UpdateWithConflictResolution
464 * @tc.type: FUNC
465 */
466 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_001, TestSize.Level1)
467 {
468 std::shared_ptr<RdbStore> store = *GetParam();
469
470 ValuesBucket values;
471 int changedRows;
472 int64_t id;
473
474 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
475 EXPECT_EQ(ret, E_OK);
476 EXPECT_EQ(1, id);
477
478 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
479 EXPECT_EQ(ret, E_OK);
480 EXPECT_EQ(2, id);
481
482 // update lisi age=19 to wangjing age=20
483 values.PutInt("id", 3);
484 values.PutString("name", std::string("wangjing"));
485 values.PutInt("age", 20);
486 values.PutDouble("salary", 300.5);
487 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
488 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = 19");
489 EXPECT_EQ(ret, E_OK);
490 EXPECT_EQ(1, changedRows);
491
492 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
493 EXPECT_NE(resultSet, nullptr);
494
495 ret = resultSet->GoToNextRow();
496 EXPECT_EQ(ret, E_OK);
497 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
498
499 ret = resultSet->GoToNextRow();
500 EXPECT_EQ(ret, E_OK);
501 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
502
503 ret = resultSet->GoToNextRow();
504 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
505
506 ret = resultSet->Close();
507 EXPECT_EQ(ret, E_OK);
508 }
509
510 /**
511 * @tc.name: RdbStore_UpdateWithConflictResolution_002
512 * @tc.desc: test RdbStore UpdateWithConflictResolution
513 * @tc.type: FUNC
514 */
515 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize.Level1)
516 {
517 std::shared_ptr<RdbStore> store = *GetParam();
518
519 ValuesBucket values;
520 int changedRows;
521 int64_t id;
522
523 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
524 EXPECT_EQ(ret, E_OK);
525 EXPECT_EQ(1, id);
526
527 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
528 EXPECT_EQ(ret, E_OK);
529 EXPECT_EQ(2, id);
530
531 // update lisi age=19 to zhangsan age=20
532 values.PutInt("id", 3);
533 values.PutString("name", std::string("zhangsan"));
534 values.PutInt("age", 20);
535 values.PutDouble("salary", 300.5);
536 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
537 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
538 ConflictResolution::ON_CONFLICT_NONE);
539 EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
540
541 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
542 EXPECT_NE(resultSet, nullptr);
543
544 ret = resultSet->GoToNextRow();
545 EXPECT_EQ(ret, E_OK);
546 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
547
548 ret = resultSet->GoToNextRow();
549 EXPECT_EQ(ret, E_OK);
550 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
551
552 ret = resultSet->GoToNextRow();
553 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
554
555 ret = resultSet->Close();
556 EXPECT_EQ(ret, E_OK);
557 }
558
559 /**
560 * @tc.name: RdbStore_UpdateWithConflictResolution_003
561 * @tc.desc: test RdbStore UpdateWithConflictResolution
562 * @tc.type: FUNC
563 */
564 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize.Level1)
565 {
566 std::shared_ptr<RdbStore> store = *GetParam();
567
568 ValuesBucket values;
569 int changedRows;
570 int64_t id;
571
572 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
573 EXPECT_EQ(ret, E_OK);
574 EXPECT_EQ(1, id);
575
576 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
577 EXPECT_EQ(ret, E_OK);
578 EXPECT_EQ(2, id);
579
580 // update lisi age=19 to wangjing age=20
581 values.PutInt("id", 3);
582 values.PutString("name", std::string("wangjing"));
583 values.PutInt("age", 20);
584 values.PutDouble("salary", 300.5);
585 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
586 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
587 ConflictResolution::ON_CONFLICT_ROLLBACK);
588 EXPECT_EQ(ret, E_OK);
589 EXPECT_EQ(1, changedRows);
590
591 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
592 EXPECT_NE(resultSet, nullptr);
593
594 ret = resultSet->GoToNextRow();
595 EXPECT_EQ(ret, E_OK);
596 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
597
598 ret = resultSet->GoToNextRow();
599 EXPECT_EQ(ret, E_OK);
600 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
601
602 ret = resultSet->GoToNextRow();
603 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
604
605 ret = resultSet->Close();
606 EXPECT_EQ(ret, E_OK);
607 }
608
609 /**
610 * @tc.name: RdbStore_UpdateWithConflictResolution_004
611 * @tc.desc: test RdbStore UpdateWithConflictResolution
612 * @tc.type: FUNC
613 */
614 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize.Level1)
615 {
616 std::shared_ptr<RdbStore> store = *GetParam();
617
618 ValuesBucket values;
619 int changedRows;
620 int64_t id;
621
622 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
623 EXPECT_EQ(ret, E_OK);
624 EXPECT_EQ(1, id);
625
626 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
627 EXPECT_EQ(ret, E_OK);
628 EXPECT_EQ(2, id);
629
630 // update lisi age=19 to zhangsan age=20
631 values.PutInt("id", 3);
632 values.PutString("name", std::string("zhangsan"));
633 values.PutInt("age", 20);
634 values.PutDouble("salary", 300.5);
635 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
636 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
637 ConflictResolution::ON_CONFLICT_ROLLBACK);
638 EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
639
640 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
641 EXPECT_NE(resultSet, nullptr);
642
643 ret = resultSet->GoToNextRow();
644 EXPECT_EQ(ret, E_OK);
645 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
646
647 ret = resultSet->GoToNextRow();
648 EXPECT_EQ(ret, E_OK);
649 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
650
651 ret = resultSet->GoToNextRow();
652 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
653
654 ret = resultSet->Close();
655 EXPECT_EQ(ret, E_OK);
656 }
657
658 /**
659 * @tc.name: RdbStore_UpdateWithConflictResolution_005
660 * @tc.desc: test RdbStore UpdateWithConflictResolution
661 * @tc.type: FUNC
662 */
663 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize.Level1)
664 {
665 std::shared_ptr<RdbStore> store = *GetParam();
666
667 ValuesBucket values;
668 int changedRows;
669 int64_t id;
670
671 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
672 EXPECT_EQ(ret, E_OK);
673 EXPECT_EQ(1, id);
674
675 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
676 EXPECT_EQ(ret, E_OK);
677 EXPECT_EQ(2, id);
678
679 // update lisi age=19 to wangjing age=20
680 values.PutInt("id", 3);
681 values.PutString("name", std::string("wangjing"));
682 values.PutInt("age", 20);
683 values.PutDouble("salary", 300.5);
684 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
685 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
686 ConflictResolution::ON_CONFLICT_REPLACE);
687 EXPECT_EQ(ret, E_OK);
688 EXPECT_EQ(1, changedRows);
689
690 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
691 EXPECT_NE(resultSet, nullptr);
692
693 ret = resultSet->GoToNextRow();
694 EXPECT_EQ(ret, E_OK);
695 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
696
697 ret = resultSet->GoToNextRow();
698 EXPECT_EQ(ret, E_OK);
699 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
700
701 ret = resultSet->GoToNextRow();
702 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
703
704 ret = resultSet->Close();
705 EXPECT_EQ(ret, E_OK);
706 }
707
708 /**
709 * @tc.name: RdbStore_UpdateWithConflictResolution_006
710 * @tc.desc: test RdbStore UpdateWithConflictResolution
711 * @tc.type: FUNC
712 */
713 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize.Level1)
714 {
715 std::shared_ptr<RdbStore> store = *GetParam();
716
717 ValuesBucket values;
718 int changedRows;
719 int64_t id;
720
721 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
722 EXPECT_EQ(ret, E_OK);
723 EXPECT_EQ(1, id);
724
725 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
726 EXPECT_EQ(ret, E_OK);
727 EXPECT_EQ(2, id);
728
729 // update lisi age=19 to zhangsan age=20
730 values.PutString("name", std::string("zhangsan"));
731 values.PutInt("age", 20);
732 values.PutDouble("salary", 300.5);
733 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
734 ConflictResolution::ON_CONFLICT_REPLACE);
735 EXPECT_EQ(ret, E_OK);
736 EXPECT_EQ(changedRows, 1);
737
738 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
739 EXPECT_NE(resultSet, nullptr);
740
741 ret = resultSet->GoToNextRow();
742 EXPECT_EQ(ret, E_OK);
743
744 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "zhangsan", 20, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
745
746 ret = resultSet->GoToNextRow();
747 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
748
749 ret = resultSet->Close();
750 EXPECT_EQ(ret, E_OK);
751 }
752
753 /**
754 * @tc.name: RdbStore_UpdateWithConflictResolution_007
755 * @tc.desc: test RdbStore UpdateWithConflictResolution
756 * @tc.type: FUNC
757 */
758 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_007, TestSize.Level1)
759 {
760 std::shared_ptr<RdbStore> store = *GetParam();
761
762 int changedRows = 0;
763 int64_t id = -1;
764 ValuesBucket values;
765
766 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
767 EXPECT_EQ(ret, E_OK);
768 EXPECT_EQ(1, id);
769
770 values.PutInt("id", 2);
771 values.PutInt("age", 19);
772 ret = store->UpdateWithConflictResolution(
773 changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" }, static_cast<ConflictResolution>(6));
774 EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
775 EXPECT_EQ(0, changedRows);
776
777 values.Clear();
778 values.PutInt("id", 2);
779 values.PutInt("age", 19);
780 ret = store->UpdateWithConflictResolution(
781 changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" }, static_cast<ConflictResolution>(-1));
782 EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
783 EXPECT_EQ(0, changedRows);
784 }
785
ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> & resultSet,const RowData & expect)786 void RdbStoreUpdateTest::ExpectValue(
787 const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet, const RowData &expect)
788 {
789 EXPECT_NE(nullptr, resultSet);
790 int columnIndex;
791 int intVal;
792 int ret;
793
794 if (expect.id != -1) {
795 ret = resultSet->GetColumnIndex("id", columnIndex);
796 EXPECT_EQ(ret, E_OK);
797 ret = resultSet->GetInt(columnIndex, intVal);
798 EXPECT_EQ(ret, E_OK);
799 EXPECT_EQ(expect.id, intVal);
800 }
801 if (expect.name != "") {
802 std::string strVal;
803 ret = resultSet->GetColumnIndex("name", columnIndex);
804 EXPECT_EQ(ret, E_OK);
805 ret = resultSet->GetString(columnIndex, strVal);
806 EXPECT_EQ(ret, E_OK);
807 EXPECT_EQ(expect.name, strVal);
808 }
809 if (expect.age != -1) {
810 ret = resultSet->GetColumnIndex("age", columnIndex);
811 EXPECT_EQ(ret, E_OK);
812 ret = resultSet->GetInt(columnIndex, intVal);
813 EXPECT_EQ(ret, E_OK);
814 EXPECT_EQ(expect.age, intVal);
815 }
816 if (expect.salary != -1) {
817 double dVal;
818 ret = resultSet->GetColumnIndex("salary", columnIndex);
819 EXPECT_EQ(ret, E_OK);
820 ret = resultSet->GetDouble(columnIndex, dVal);
821 EXPECT_EQ(ret, E_OK);
822 EXPECT_EQ(expect.salary, dVal);
823 }
824 if (expect.blobType.size() != 0) {
825 std::vector<uint8_t> blob;
826 ret = resultSet->GetColumnIndex("blobType", columnIndex);
827 EXPECT_EQ(ret, E_OK);
828 ret = resultSet->GetBlob(columnIndex, blob);
829 EXPECT_EQ(ret, E_OK);
830 EXPECT_EQ(expect.blobType.size(), static_cast<int>(blob.size()));
831 for (int i = 0; i < expect.blobType.size(); i++) {
832 EXPECT_EQ(expect.blobType[i], blob[i]);
833 }
834 }
835 }
836
837 /**
838 * @tc.name: OverLimitWithUpdate_001
839 * @tc.desc: over limit
840 * @tc.type: FUNC
841 * @tc.require:
842 * @tc.author:
843 */
844 HWTEST_P(RdbStoreUpdateTest, OverLimitWithUpdate_001, TestSize.Level1)
845 {
846 std::shared_ptr<RdbStore> store = *GetParam();
847 auto [code, maxPageCount] = store->Execute("PRAGMA max_page_count;");
__anon86c544cc0102(const char *) 848 auto recover = std::shared_ptr<const char>("recover", [defPageCount = maxPageCount, store](const char *) {
849 store->Execute("PRAGMA max_page_count = " + static_cast<std::string>(defPageCount) + ";");
850 });
851 std::tie(code, maxPageCount) = store->Execute("PRAGMA max_page_count = 256;");
852
853 int64_t id = -1;
854 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
855 ASSERT_EQ(ret, E_OK);
856
857 ValuesBucket row;
858 row.PutInt("id", id);
859 row.Put("name", std::string(1024 * 1024, 'e'));
860 row.PutInt("age", 20);
861 row.PutDouble("salary", 200.5);
862 row.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
863 int changedRows;
864 auto result = store->Update(changedRows, "test", row);
865 ASSERT_EQ(result, E_SQLITE_FULL);
866 }
867
868 INSTANTIATE_TEST_SUITE_P(UpdateTest, RdbStoreUpdateTest, testing::Values(&g_store, &g_memDb));
869 } // namespace OHOS::RdbStoreUpdateTest