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 ASSERT_NE(store_, nullptr);
103 store_->ExecuteSql("DELETE FROM test");
104 }
105
TearDown(void)106 void RdbStoreUpdateTest::TearDown(void)
107 {
108 RdbHelper::ClearCache();
109 }
110
111 /**
112 * @tc.name: RdbStore_Update_001
113 * @tc.desc: test RdbStore update, select id and update one row
114 * @tc.type: FUNC
115 */
116 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_001, TestSize.Level1)
117 {
118 ValuesBucket values;
119 int changedRows;
120 int64_t id;
121
122 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
123 EXPECT_EQ(ret, E_OK);
124 EXPECT_EQ(1, id);
125
126 values.Clear();
127 values.PutInt("id", 2);
128 values.PutString("name", std::string("lisi"));
129 values.PutInt("age", 20);
130 values.PutDouble("salary", 200.5);
131 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
132 ret = store_->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
133 EXPECT_EQ(ret, E_OK);
134 EXPECT_EQ(1, changedRows);
135
136 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
137 EXPECT_NE(resultSet, nullptr);
138
139 ret = resultSet->GoToFirstRow();
140 EXPECT_EQ(ret, E_OK);
141 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
142
143 ret = resultSet->GoToNextRow();
144 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
145
146 ret = resultSet->Close();
147 EXPECT_EQ(ret, E_OK);
148 }
149
150 /**
151 * @tc.name: RdbStore_Update_002
152 * @tc.desc: test RdbStore update, no select and update all rows
153 * @tc.type: FUNC
154 */
155 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_002, TestSize.Level1)
156 {
157 int64_t id;
158 ValuesBucket values;
159 int changedRows;
160
161 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
162 EXPECT_EQ(ret, E_OK);
163 EXPECT_EQ(1, id);
164
165 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
166 EXPECT_EQ(ret, E_OK);
167 EXPECT_EQ(2, id);
168
169 values.Clear();
170 values.PutDouble("salary", 300.5);
171 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
172 ret = store_->Update(changedRows, "test", values);
173 EXPECT_EQ(ret, E_OK);
174 EXPECT_EQ(2, changedRows);
175
176 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
177 EXPECT_NE(resultSet, nullptr);
178
179 ret = resultSet->GoToNextRow();
180 EXPECT_EQ(ret, E_OK);
181 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
182
183 ret = resultSet->GoToNextRow();
184 EXPECT_EQ(ret, E_OK);
185 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
186
187 ret = resultSet->GoToNextRow();
188 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
189
190 ret = resultSet->Close();
191 EXPECT_EQ(ret, E_OK);
192 }
193
194 /**
195 * @tc.name: RdbStore_Update_003
196 * @tc.desc: test RdbStore update
197 * @tc.type: FUNC
198 */
199 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_003, TestSize.Level1)
200 {
201 int changedRows;
202 ValuesBucket values;
203 values.PutInt("id", 1);
204 values.PutString("name", std::string("zhangsan"));
205 values.PutInt("age", 18);
206 values.PutDouble("salary", 100.5);
207 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
208 int ret = store_->Update(changedRows, "", values, "", std::vector<std::string>()); // empty table name
209 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
210
211 ret = store_->Update(changedRows, "wrongTable", values, "", std::vector<std::string>()); // no such table
212 EXPECT_EQ(ret, E_SQLITE_ERROR);
213 }
214
215 /**
216 * @tc.name: RdbStore_Update_004
217 * @tc.desc: test RdbStore insert
218 * @tc.type: FUNC
219 */
220 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_004, TestSize.Level1)
221 {
222 int changedRows;
223 ValuesBucket emptyBucket;
224 int ret = store_->Update(changedRows, "test", emptyBucket);
225 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
226
227 ValuesBucket values;
228 values.PutInt("id", 1);
229 values.PutString("name", std::string("zhangsan"));
230 values.PutInt("age", 18);
231 values.PutDouble("wrongColumn", 100.5); // no such column
232 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
233 ret = store_->Update(changedRows, "test", values, "", std::vector<std::string>());
234 EXPECT_EQ(ret, E_SQLITE_ERROR);
235 }
236
237 /**
238 * @tc.name: RdbStore_Update_005
239 * @tc.desc: test RdbStore insert
240 * @tc.type: FUNC
241 */
242 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_005, TestSize.Level1)
243 {
244 ValuesBucket values;
245 int changedRows;
246 int64_t id;
247
248 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
249 EXPECT_EQ(ret, E_OK);
250 EXPECT_EQ(1, id);
251
252 ret = store_->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
253 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
254 }
255
256 /**
257 * @tc.name: RdbStore_Update_006
258 * @tc.desc: test RdbStore insert
259 * @tc.type: FUNC
260 */
261 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_006, TestSize.Level1)
262 {
263 ValuesBucket values;
264 int changedRows;
265 int64_t id;
266
267 values.Clear();
268 values.PutString("id", "2");
269 values.PutString("name", std::string("lisi"));
270 values.PutInt("age", 20);
271 values.PutDouble("salary", 200.5);
272 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
273 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
274 EXPECT_EQ(ret, E_OK);
275 EXPECT_EQ(1, id);
276
277 ret = store_->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
278 EXPECT_EQ(ret, E_OK);
279 EXPECT_EQ(1, changedRows);
280
281 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
282 EXPECT_NE(resultSet, nullptr);
283
284 ret = resultSet->GoToFirstRow();
285 EXPECT_EQ(ret, E_OK);
286 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
287
288 ret = resultSet->GoToNextRow();
289 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
290
291 ret = resultSet->Close();
292 EXPECT_EQ(ret, E_OK);
293 }
294
295 /**
296 * @tc.name: RdbStore_Update_007
297 * @tc.desc: test RdbStore update asset
298 * @tc.type: FUNC
299 */
300 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_007, TestSize.Level1)
301 {
302 ValuesBucket values;
303 AssetValue value{ .version = 1, .name = "123", .uri = "your test path", .createTime = "13", .modifyTime = "13" };
304 int changedRows;
305 int64_t id;
306 values.PutNull("assetType");
307 int ret = store_->Insert(id, "test", values);
308 EXPECT_EQ(ret, E_OK);
309 EXPECT_EQ(3, id);
310 values.Clear();
311 values.Put("assetType", value);
312 ret = store_->Update(changedRows, "test", values);
313 EXPECT_EQ(ret, E_OK);
314 EXPECT_EQ(1, changedRows);
315 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
316 EXPECT_NE(resultSet, nullptr);
317
318 ret = resultSet->GoToFirstRow();
319 EXPECT_EQ(ret, E_OK);
320
321 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ .id = 3,
322 .asset{ .version = 1,
323 .status = AssetValue::STATUS_INSERT,
324 .name = "123",
325 .uri = "your test path",
326 .createTime = "13",
327 .modifyTime = "13" } });
328 ret = resultSet->Close();
329 EXPECT_EQ(ret, E_OK);
330 }
331
332 /**
333 * @tc.name: RdbStore_Update_008
334 * @tc.desc: test RdbStore update asset
335 * @tc.type: FUNC
336 */
337 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_008, TestSize.Level1)
338 {
339 ValuesBucket values;
340 AssetValue valueDef{
341 .version = 0,
342 .name = "123",
343 .uri = "my test path",
344 .createTime = "12",
345 .modifyTime = "12",
346 };
347 AssetValue value{ .version = 2, .name = "456", .uri = "your test path", .createTime = "15", .modifyTime = "15" };
348 int changedRows;
349 int64_t id;
350 values.Put("assetType", valueDef);
351 int ret = store_->Insert(id, "test", values);
352 EXPECT_EQ(ret, E_OK);
353 EXPECT_EQ(4, id);
354 values.Clear();
355 values.Put("assetType", value);
356 ret = store_->Update(changedRows, "test", values);
357 EXPECT_EQ(ret, E_OK);
358 EXPECT_EQ(1, changedRows);
359 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
360 EXPECT_NE(resultSet, nullptr);
361
362 ret = resultSet->GoToFirstRow();
363 EXPECT_EQ(ret, E_OK);
364 RdbStoreUpdateTest::ExpectValue(resultSet,
365 RowData{ .id = 4,
366 .asset{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" } });
367 ret = resultSet->Close();
368 EXPECT_EQ(ret, E_OK);
369 }
370
371 /**
372 * @tc.name: RdbStore_Update_009
373 * @tc.desc: test RdbStore update asset
374 * @tc.type: FUNC
375 */
376 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_009, TestSize.Level1)
377 {
378 ValuesBucket values;
379 AssetValue valueDef{ .version = 0,
380 .status = AssetValue::STATUS_NORMAL,
381 .name = "123",
382 .uri = "my test path",
383 .createTime = "12",
384 .modifyTime = "12",
385 .size = "543",
386 .hash = "321" };
387 AssetValue value{ .name = "123" };
388 value.status = AssetValue::STATUS_DELETE;
389 int changedRows;
390 int64_t id;
391 values.Put("assetType", valueDef);
392 int ret = store_->Insert(id, "test", values);
393 EXPECT_EQ(ret, E_OK);
394 EXPECT_EQ(5, id);
395 values.Clear();
396 values.Put("assetType", value);
397 ret = store_->Update(changedRows, "test", values);
398 EXPECT_EQ(ret, E_OK);
399 EXPECT_EQ(1, changedRows);
400 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
401 EXPECT_NE(resultSet, nullptr);
402 ret = resultSet->GoToFirstRow();
403 EXPECT_EQ(ret, E_OK);
404 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ .id = 5,
405 .asset{ .version = 0,
406 .status = AssetValue::Status::STATUS_DELETE,
407 .name = "123",
408 .uri = "my test path",
409 .createTime = "12",
410 .modifyTime = "",
411 .size = "",
412 .hash = "" } });
413 ret = resultSet->Close();
414 EXPECT_EQ(ret, E_OK);
415 }
416
417 /**
418 * @tc.name: RdbStore_Update_010
419 * @tc.desc: test RdbStore update assets
420 * @tc.type: FUNC
421 */
422 HWTEST_P(RdbStoreUpdateTest, RdbStore_Update_010, TestSize.Level1)
423 {
424 ValuesBucket values;
425 std::vector<AssetValue> assetsDef{
426 { .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" }
427 };
428 AssetValue value1{ .version = 1, .name = "123", .uri = "your test path", .createTime = "13", .modifyTime = "13" };
429 AssetValue value2{ .version = 2, .name = "123", .uri = "your test path", .createTime = "14", .modifyTime = "14" };
430 AssetValue value3{ .version = 3, .name = "456", .uri = "your test path", .createTime = "15", .modifyTime = "15" };
431 auto assets = ValueObject::Assets({ value1, value2, value3 });
432 int changedRows;
433 int64_t id;
434 values.Put("assetsType", assetsDef);
435 int ret = store_->Insert(id, "test", values);
436 EXPECT_EQ(ret, E_OK);
437 EXPECT_EQ(6, id);
438 values.Clear();
439 values.Put("assetsType", assets);
440
441 ret = store_->Update(changedRows, "test", values);
442 EXPECT_EQ(ret, E_OK);
443 EXPECT_EQ(1, changedRows);
444 }
445
446 /**
447 * @tc.name: RdbStore_UpdateWithConflictResolution_001
448 * @tc.desc: test RdbStore UpdateWithConflictResolution
449 * @tc.type: FUNC
450 */
451 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_001, TestSize.Level1)
452 {
453 ValuesBucket values;
454 int changedRows;
455 int64_t id;
456
457 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
458 EXPECT_EQ(ret, E_OK);
459 EXPECT_EQ(1, id);
460
461 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
462 EXPECT_EQ(ret, E_OK);
463 EXPECT_EQ(2, id);
464
465 // update lisi age=19 to wangjing age=20
466 values.PutInt("id", 3);
467 values.PutString("name", std::string("wangjing"));
468 values.PutInt("age", 20);
469 values.PutDouble("salary", 300.5);
470 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
471 ret = store_->UpdateWithConflictResolution(changedRows, "test", values, "age = 19");
472 EXPECT_EQ(ret, E_OK);
473 EXPECT_EQ(1, changedRows);
474
475 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
476 EXPECT_NE(resultSet, nullptr);
477
478 ret = resultSet->GoToNextRow();
479 EXPECT_EQ(ret, E_OK);
480 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
481
482 ret = resultSet->GoToNextRow();
483 EXPECT_EQ(ret, E_OK);
484 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
485
486 ret = resultSet->GoToNextRow();
487 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
488
489 ret = resultSet->Close();
490 EXPECT_EQ(ret, E_OK);
491 }
492
493 /**
494 * @tc.name: RdbStore_UpdateWithConflictResolution_002
495 * @tc.desc: test RdbStore UpdateWithConflictResolution
496 * @tc.type: FUNC
497 */
498 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize.Level1)
499 {
500 ValuesBucket values;
501 int changedRows;
502 int64_t id;
503
504 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
505 EXPECT_EQ(ret, E_OK);
506 EXPECT_EQ(1, id);
507
508 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
509 EXPECT_EQ(ret, E_OK);
510 EXPECT_EQ(2, id);
511
512 // update lisi age=19 to zhangsan age=20
513 values.PutInt("id", 3);
514 values.PutString("name", std::string("zhangsan"));
515 values.PutInt("age", 20);
516 values.PutDouble("salary", 300.5);
517 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
518 ret = store_->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
519 ConflictResolution::ON_CONFLICT_NONE);
520 EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
521
522 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
523 EXPECT_NE(resultSet, nullptr);
524
525 ret = resultSet->GoToNextRow();
526 EXPECT_EQ(ret, E_OK);
527 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
528
529 ret = resultSet->GoToNextRow();
530 EXPECT_EQ(ret, E_OK);
531 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
532
533 ret = resultSet->GoToNextRow();
534 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
535
536 ret = resultSet->Close();
537 EXPECT_EQ(ret, E_OK);
538 }
539
540 /**
541 * @tc.name: RdbStore_UpdateWithConflictResolution_003
542 * @tc.desc: test RdbStore UpdateWithConflictResolution
543 * @tc.type: FUNC
544 */
545 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize.Level1)
546 {
547 ValuesBucket values;
548 int changedRows;
549 int64_t id;
550
551 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
552 EXPECT_EQ(ret, E_OK);
553 EXPECT_EQ(1, id);
554
555 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
556 EXPECT_EQ(ret, E_OK);
557 EXPECT_EQ(2, id);
558
559 // update lisi age=19 to wangjing age=20
560 values.PutInt("id", 3);
561 values.PutString("name", std::string("wangjing"));
562 values.PutInt("age", 20);
563 values.PutDouble("salary", 300.5);
564 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
565 ret = store_->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
566 ConflictResolution::ON_CONFLICT_ROLLBACK);
567 EXPECT_EQ(ret, E_OK);
568 EXPECT_EQ(1, changedRows);
569
570 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
571 EXPECT_NE(resultSet, nullptr);
572
573 ret = resultSet->GoToNextRow();
574 EXPECT_EQ(ret, E_OK);
575 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
576
577 ret = resultSet->GoToNextRow();
578 EXPECT_EQ(ret, E_OK);
579 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
580
581 ret = resultSet->GoToNextRow();
582 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
583
584 ret = resultSet->Close();
585 EXPECT_EQ(ret, E_OK);
586 }
587
588 /**
589 * @tc.name: RdbStore_UpdateWithConflictResolution_004
590 * @tc.desc: test RdbStore UpdateWithConflictResolution
591 * @tc.type: FUNC
592 */
593 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize.Level1)
594 {
595 ValuesBucket values;
596 int changedRows;
597 int64_t id;
598
599 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
600 EXPECT_EQ(ret, E_OK);
601 EXPECT_EQ(1, id);
602
603 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
604 EXPECT_EQ(ret, E_OK);
605 EXPECT_EQ(2, id);
606
607 // update lisi age=19 to zhangsan age=20
608 values.PutInt("id", 3);
609 values.PutString("name", std::string("zhangsan"));
610 values.PutInt("age", 20);
611 values.PutDouble("salary", 300.5);
612 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
613 ret = store_->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
614 ConflictResolution::ON_CONFLICT_ROLLBACK);
615 EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
616
617 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
618 EXPECT_NE(resultSet, nullptr);
619
620 ret = resultSet->GoToNextRow();
621 EXPECT_EQ(ret, E_OK);
622 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
623
624 ret = resultSet->GoToNextRow();
625 EXPECT_EQ(ret, E_OK);
626 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
627
628 ret = resultSet->GoToNextRow();
629 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
630
631 ret = resultSet->Close();
632 EXPECT_EQ(ret, E_OK);
633 }
634
635 /**
636 * @tc.name: RdbStore_UpdateWithConflictResolution_005
637 * @tc.desc: test RdbStore UpdateWithConflictResolution
638 * @tc.type: FUNC
639 */
640 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize.Level1)
641 {
642 ValuesBucket values;
643 int changedRows;
644 int64_t id;
645
646 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
647 EXPECT_EQ(ret, E_OK);
648 EXPECT_EQ(1, id);
649
650 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
651 EXPECT_EQ(ret, E_OK);
652 EXPECT_EQ(2, id);
653
654 // update lisi age=19 to wangjing age=20
655 values.PutInt("id", 3);
656 values.PutString("name", std::string("wangjing"));
657 values.PutInt("age", 20);
658 values.PutDouble("salary", 300.5);
659 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
660 ret = store_->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
661 ConflictResolution::ON_CONFLICT_REPLACE);
662 EXPECT_EQ(ret, E_OK);
663 EXPECT_EQ(1, changedRows);
664
665 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
666 EXPECT_NE(resultSet, nullptr);
667
668 ret = resultSet->GoToNextRow();
669 EXPECT_EQ(ret, E_OK);
670 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
671
672 ret = resultSet->GoToNextRow();
673 EXPECT_EQ(ret, E_OK);
674 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
675
676 ret = resultSet->GoToNextRow();
677 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
678
679 ret = resultSet->Close();
680 EXPECT_EQ(ret, E_OK);
681 }
682
683 /**
684 * @tc.name: RdbStore_UpdateWithConflictResolution_006
685 * @tc.desc: test RdbStore UpdateWithConflictResolution
686 * @tc.type: FUNC
687 */
688 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize.Level1)
689 {
690 ValuesBucket values;
691 int changedRows;
692 int64_t id;
693
694 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
695 EXPECT_EQ(ret, E_OK);
696 EXPECT_EQ(1, id);
697
698 ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
699 EXPECT_EQ(ret, E_OK);
700 EXPECT_EQ(2, id);
701
702 // update lisi age=19 to zhangsan age=20
703 values.PutString("name", std::string("zhangsan"));
704 values.PutInt("age", 20);
705 values.PutDouble("salary", 300.5);
706 ret = store_->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
707 ConflictResolution::ON_CONFLICT_REPLACE);
708 EXPECT_EQ(ret, E_OK);
709 EXPECT_EQ(changedRows, 1);
710
711 std::shared_ptr<ResultSet> resultSet = store_->QuerySql("SELECT * FROM test");
712 EXPECT_NE(resultSet, nullptr);
713
714 ret = resultSet->GoToNextRow();
715 EXPECT_EQ(ret, E_OK);
716
717 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "zhangsan", 20, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
718
719 ret = resultSet->GoToNextRow();
720 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
721
722 ret = resultSet->Close();
723 EXPECT_EQ(ret, E_OK);
724 }
725
726 /**
727 * @tc.name: RdbStore_UpdateWithConflictResolution_007
728 * @tc.desc: test RdbStore UpdateWithConflictResolution
729 * @tc.type: FUNC
730 */
731 HWTEST_P(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_007, TestSize.Level1)
732 {
733 int changedRows = 0;
734 int64_t id = -1;
735 ValuesBucket values;
736
737 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
738 EXPECT_EQ(ret, E_OK);
739 EXPECT_EQ(1, id);
740
741 values.PutInt("id", 2);
742 values.PutInt("age", 19);
743 ret = store_->UpdateWithConflictResolution(
744 changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" }, static_cast<ConflictResolution>(6));
745 EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
746 EXPECT_EQ(0, changedRows);
747
748 values.Clear();
749 values.PutInt("id", 2);
750 values.PutInt("age", 19);
751 ret = store_->UpdateWithConflictResolution(
752 changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" }, static_cast<ConflictResolution>(-1));
753 EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
754 EXPECT_EQ(0, changedRows);
755 }
756
ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> & resultSet,const RowData & expect)757 void RdbStoreUpdateTest::ExpectValue(
758 const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet, const RowData &expect)
759 {
760 EXPECT_NE(nullptr, resultSet);
761 int columnIndex;
762 int intVal;
763 int ret;
764
765 if (expect.id != -1) {
766 ret = resultSet->GetColumnIndex("id", columnIndex);
767 EXPECT_EQ(ret, E_OK);
768 ret = resultSet->GetInt(columnIndex, intVal);
769 EXPECT_EQ(ret, E_OK);
770 EXPECT_EQ(expect.id, intVal);
771 }
772 if (expect.name != "") {
773 std::string strVal;
774 ret = resultSet->GetColumnIndex("name", columnIndex);
775 EXPECT_EQ(ret, E_OK);
776 ret = resultSet->GetString(columnIndex, strVal);
777 EXPECT_EQ(ret, E_OK);
778 EXPECT_EQ(expect.name, strVal);
779 }
780 if (expect.age != -1) {
781 ret = resultSet->GetColumnIndex("age", columnIndex);
782 EXPECT_EQ(ret, E_OK);
783 ret = resultSet->GetInt(columnIndex, intVal);
784 EXPECT_EQ(ret, E_OK);
785 EXPECT_EQ(expect.age, intVal);
786 }
787 if (expect.salary != -1) {
788 double dVal;
789 ret = resultSet->GetColumnIndex("salary", columnIndex);
790 EXPECT_EQ(ret, E_OK);
791 ret = resultSet->GetDouble(columnIndex, dVal);
792 EXPECT_EQ(ret, E_OK);
793 EXPECT_EQ(expect.salary, dVal);
794 }
795 if (expect.blobType.size() != 0) {
796 std::vector<uint8_t> blob;
797 ret = resultSet->GetColumnIndex("blobType", columnIndex);
798 EXPECT_EQ(ret, E_OK);
799 ret = resultSet->GetBlob(columnIndex, blob);
800 EXPECT_EQ(ret, E_OK);
801 EXPECT_EQ(expect.blobType.size(), static_cast<int>(blob.size()));
802 for (int i = 0; i < expect.blobType.size(); i++) {
803 EXPECT_EQ(expect.blobType[i], blob[i]);
804 }
805 }
806 }
807
808 /**
809 * @tc.name: OverLimitWithUpdate_001
810 * @tc.desc: over limit
811 * @tc.type: FUNC
812 * @tc.require:
813 * @tc.author:
814 */
815 HWTEST_P(RdbStoreUpdateTest, OverLimitWithUpdate_001, TestSize.Level1)
816 {
817 std::shared_ptr<RdbStore> store = *GetParam();
818 auto [code, maxPageCount] = store->Execute("PRAGMA max_page_count;");
__anonc237a86e0102(const char *) 819 auto recover = std::shared_ptr<const char>("recover", [defPageCount = maxPageCount, store](const char *) {
820 store->Execute("PRAGMA max_page_count = " + static_cast<std::string>(defPageCount) + ";");
821 });
822 std::tie(code, maxPageCount) = store->Execute("PRAGMA max_page_count = 256;");
823
824 int64_t id = -1;
825 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
826 ASSERT_EQ(ret, E_OK);
827
828 ValuesBucket row;
829 row.PutInt("id", id);
830 row.Put("name", std::string(1024 * 1024, 'e'));
831 row.PutInt("age", 20);
832 row.PutDouble("salary", 200.5);
833 row.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
834 int changedRows;
835 auto result = store->Update(changedRows, "test", row);
836 ASSERT_EQ(result, E_SQLITE_FULL);
837 }
838
839 /**
840 * @tc.name: UpdateWithReturning_001
841 * @tc.desc: normal test
842 * @tc.type: FUNC
843 * @tc.require:
844 * @tc.author:
845 */
846 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_001, TestSize.Level1)
847 {
848 int64_t id;
849 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
850 EXPECT_EQ(ret, E_OK);
851 EXPECT_EQ(1, id);
852
853 ValuesBucket values;
854 values.PutInt("id", 2);
855 values.PutString("name", std::string("lisi"));
856 values.PutInt("age", 20);
857 values.PutDouble("salary", 200.5);
858 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
859 AbsRdbPredicates predicates("test");
860 auto [status, result] = store_->Update(values, predicates, { "id" });
861 EXPECT_EQ(status, E_OK);
862 EXPECT_EQ(result.changed, 1);
863 int rowCount = -1;
864 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
865 ASSERT_EQ(rowCount, 1);
866 int columnIndex = -1;
867 ASSERT_EQ(result.results->GetColumnIndex("id", columnIndex), E_OK);
868 int val = -1;
869 ASSERT_EQ(result.results->GetInt(columnIndex, val), E_OK);
870 }
871
872 /**
873 * @tc.name: UpdateWithReturning_002
874 * @tc.desc: abnormal test, update with conflict ignore and partial Success
875 * @tc.type: FUNC
876 * @tc.require:
877 * @tc.author:
878 */
879 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_002, TestSize.Level1)
880 {
881 ValuesBuckets rows;
882 for (int i = 0; i < 5; i++) {
883 ValuesBucket row;
884 row.Put("id", i);
885 row.Put("name", "Jim_" + std::to_string(i));
886 rows.Put(row);
887 }
888 auto [status, result] = store_->BatchInsert("test", rows, {}, ConflictResolution::ON_CONFLICT_REPLACE);
889 ASSERT_EQ(status, E_OK);
890 ASSERT_EQ(result.changed, 5);
891 int rowCount = -1;
892 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
893 EXPECT_EQ(0, rowCount);
894
895 ValuesBucket row;
896 row.PutString("name", "Jim_3");
897 row.PutInt("age", 20);
898 row.PutDouble("salary", 200.5);
899 row.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
900 AbsRdbPredicates predicates("test");
901 predicates.In("id", { 1, 2, 3 });
902 std::tie(status, result) = store_->Update(row, predicates, { "name" }, ConflictResolution::ON_CONFLICT_IGNORE);
903 EXPECT_EQ(status, E_OK);
904 EXPECT_EQ(result.changed, 1);
905 rowCount = -1;
906 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
907 EXPECT_EQ(1, rowCount);
908 int columnIndex = -1;
909 ASSERT_EQ(result.results->GetColumnIndex("name", columnIndex), E_OK);
910 std::string val;
911 ASSERT_EQ(result.results->GetString(columnIndex, val), E_OK);
912 ASSERT_EQ(val, "Jim_3");
913 }
914
915 /**
916 * @tc.name: UpdateWithReturning_003
917 * @tc.desc: abnormal test, update with conflict abort and failed
918 * @tc.type: FUNC
919 * @tc.require:
920 * @tc.author:
921 */
922 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_003, TestSize.Level1)
923 {
924 ValuesBuckets rows;
925 for (int i = 0; i < 5; i++) {
926 ValuesBucket row;
927 row.Put("id", i);
928 row.Put("name", "Jim_" + std::to_string(i));
929 rows.Put(row);
930 }
931 auto [status, result] = store_->BatchInsert("test", rows, {}, ConflictResolution::ON_CONFLICT_REPLACE);
932 ASSERT_EQ(status, E_OK);
933 ASSERT_EQ(result.changed, 5);
934 int rowCount = -1;
935 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
936 EXPECT_EQ(0, rowCount);
937
938 ValuesBucket row;
939 row.PutString("name", "Jim_3");
940 row.PutInt("age", 20);
941 row.PutDouble("salary", 200.5);
942 row.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
943 AbsRdbPredicates predicates("test");
944 predicates.In("id", { 1, 2, 3 });
945 std::tie(status, result) = store_->Update(row, predicates, { "blobType" }, ConflictResolution::ON_CONFLICT_ABORT);
946 EXPECT_EQ(status, E_SQLITE_CONSTRAINT);
947 EXPECT_EQ(result.changed, 0);
948 rowCount = -1;
949 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
950 EXPECT_EQ(0, rowCount);
951 }
952
953 /**
954 * @tc.name: UpdateWithReturning_004
955 * @tc.desc: abnormal test, update over returning limit
956 * @tc.type: FUNC
957 * @tc.require:
958 * @tc.author:
959 */
960 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_004, TestSize.Level1)
961 {
962 ValuesBuckets rows;
963 for (int i = 0; i < 1124; i++) {
964 ValuesBucket row;
965 row.Put("id", i);
966 row.Put("name", "Jim_" + std::to_string(i));
967 rows.Put(row);
968 }
969 auto [status, result] = store_->BatchInsert("test", rows, {}, ConflictResolution::ON_CONFLICT_REPLACE);
970 ASSERT_EQ(status, E_OK);
971 ASSERT_EQ(result.changed, 1124);
972 int rowCount = -1;
973 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
974 EXPECT_EQ(0, rowCount);
975
976 ValuesBucket row;
977 row.PutInt("age", 20);
978 row.PutDouble("salary", 200.5);
979 row.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
980 AbsRdbPredicates predicates("test");
981 std::tie(status, result) = store_->Update(row, predicates, { "age" }, ConflictResolution::ON_CONFLICT_REPLACE);
982 EXPECT_EQ(status, E_OK);
983 EXPECT_EQ(result.changed, 1124);
984 rowCount = -1;
985 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
986 EXPECT_EQ(rowCount, 1024);
987 }
988
989 /**
990 * @tc.name: UpdateWithReturning_005
991 * @tc.desc: abnormal test, update with returning no exist field
992 * @tc.type: FUNC
993 * @tc.require:
994 * @tc.author:
995 */
996 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_005, TestSize.Level1)
997 {
998 int64_t id;
999 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
1000 EXPECT_EQ(ret, E_OK);
1001 EXPECT_EQ(1, id);
1002
1003 ValuesBucket values;
1004 values.PutString("name", std::string("lisi"));
1005 values.PutInt("age", 20);
1006 AbsRdbPredicates predicates("test");
1007 predicates.EqualTo("id", 10000);
1008 auto [status, result] = store_->Update(values, predicates, { "noExist" });
1009 EXPECT_EQ(status, E_SQLITE_ERROR);
1010 EXPECT_EQ(result.changed, -1);
1011 EXPECT_EQ(result.results, nullptr);
1012 }
1013
1014 /**
1015 * @tc.name: UpdateWithReturning_006
1016 * @tc.desc: abnormal test, update 0 rows
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 * @tc.author:
1020 */
1021 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_006, TestSize.Level1)
1022 {
1023 int64_t id;
1024 int ret = store_->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
1025 EXPECT_EQ(ret, E_OK);
1026 EXPECT_EQ(1, id);
1027
1028 ValuesBucket values;
1029 values.PutString("name", std::string("lisi"));
1030 values.PutInt("age", 20);
1031 AbsRdbPredicates predicates("test");
1032 predicates.EqualTo("id", 10000);
1033 auto [status, result] = store_->Update(values, predicates, { "id" });
1034 EXPECT_EQ(status, E_OK);
1035 EXPECT_EQ(result.changed, 0);
1036 int rowCount = -1;
1037 ASSERT_EQ(result.results->GetRowCount(rowCount), E_OK);
1038 EXPECT_EQ(0, rowCount);
1039 }
1040
1041
1042 /**
1043 * @tc.name: UpdateWithReturning_007
1044 * @tc.desc: abnormal test, update 0 rows
1045 * @tc.type: FUNC
1046 * @tc.require:
1047 * @tc.author:
1048 */
1049 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_007, TestSize.Level1)
1050 {
1051 store_->Execute("CREATE VIRTUAL TABLE IF NOT EXISTS articles USING fts5(title, content);");
1052 ValuesBuckets rows;
1053 ValuesBucket row;
1054 row.Put("title", "fts5");
1055 row.Put("content", "test virtual tables");
1056 rows.Put(std::move(row));
1057 auto [status, result] =
1058 store_->BatchInsert("articles", rows, { "title" }, NativeRdb::ConflictResolution::ON_CONFLICT_IGNORE);
1059 EXPECT_EQ(status, E_OK);
1060 EXPECT_EQ(result.changed, 1);
1061 ASSERT_NE(result.results, nullptr);
1062
1063 AbsRdbPredicates predicates("test");
1064 predicates.EqualTo("title", "fts5");
1065 ValuesBucket values;
1066 values.PutString("title", "fts5 updated");
1067
1068 std::tie(status, result) = store_->Update(values, predicates, { "title" });
1069 // UPDATE RETURNING is not available on virtual tables
1070 EXPECT_EQ(status, E_SQLITE_ERROR);
1071 EXPECT_EQ(result.changed, -1);
1072 EXPECT_EQ(result.results, nullptr);
1073
1074 store_->Execute("Drop TABLE articles");
1075 }
1076
1077 /**
1078 * @tc.name: UpdateWithReturning_008
1079 * @tc.desc: normal test. create trigger before update, delete data in trigger, then update data
1080 * @tc.type: FUNC
1081 * @tc.require:
1082 * @tc.author:
1083 */
1084 HWTEST_P(RdbStoreUpdateTest, UpdateWithReturning_008, TestSize.Level1)
1085 {
1086 auto [code, result1] = store_->Execute(
1087 "CREATE TRIGGER before_update BEFORE UPDATE ON test"
1088 " BEGIN DELETE FROM test WHERE name = 'wang'; END");
1089
1090 EXPECT_EQ(code, E_OK);
1091
1092 ValuesBuckets rows;
1093 ValuesBucket row;
1094 row.Put("id", 200);
1095 row.Put("name", "wang");
1096 rows.Put(std::move(row));
1097 row.Put("id", 201);
1098 row.Put("name", "zhang");
1099 rows.Put(std::move(row));
1100
1101 auto [insertStatus, insertResult] =
1102 store_->BatchInsert("test", rows, { "name" }, NativeRdb::ConflictResolution::ON_CONFLICT_IGNORE);
1103 EXPECT_EQ(insertStatus, E_OK);
1104 EXPECT_EQ(insertResult.changed, 2);
1105
1106 auto predicates = AbsRdbPredicates("test");
1107 predicates.EqualTo("name", "zhang");
1108 ValuesBucket values;
1109 values.PutString("name", "liu");
1110
1111 auto [status, res] =
1112 store_->Update(values, predicates, { "name" });
1113
1114 EXPECT_EQ(status, E_OK);
1115 EXPECT_EQ(res.changed, 1);
1116 int rowCount = -1;
1117 ASSERT_EQ(res.results->GetRowCount(rowCount), E_OK);
1118 ASSERT_EQ(rowCount, 1);
1119 int columnIndex = -1;
1120 ASSERT_EQ(res.results->GetColumnIndex("name", columnIndex), E_OK);
1121 std::string value;
1122 ASSERT_EQ(res.results->GetString(columnIndex, value), E_OK);
1123 EXPECT_EQ(value, "liu");
1124
1125 // Check the trigger effect
1126 auto resultSet = store_->QuerySql("select name from test where id = 200");
1127
1128 rowCount = -1;
1129 resultSet->GetRowCount(rowCount);
1130 ASSERT_EQ(rowCount, 0);
1131 store_->Execute("DROP TRIGGER IF EXISTS before_update");
1132 }
1133
1134 INSTANTIATE_TEST_SUITE_P(UpdateTest, RdbStoreUpdateTest, testing::Values(&g_store, &g_memDb));
1135 } // namespace OHOS::RdbStoreUpdateTest