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