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 ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
54                                                                   "name TEXT UNIQUE, age INTEGER, salary "
55                                                                   "REAL, blobType BLOB)");
56 
OnCreate(RdbStore & store)57 int UpdateTestOpenCallback::OnCreate(RdbStore &store)
58 {
59     return store.ExecuteSql(CREATE_TABLE_TEST);
60 }
61 
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)62 int UpdateTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
63 {
64     return E_OK;
65 }
66 
SetUpTestCase(void)67 void RdbStoreUpdateTest::SetUpTestCase(void)
68 {
69     int errCode = E_OK;
70     RdbHelper::DeleteRdbStore(DATABASE_NAME);
71     RdbStoreConfig config(RdbStoreUpdateTest::DATABASE_NAME);
72     UpdateTestOpenCallback helper;
73     RdbStoreUpdateTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
74     EXPECT_NE(RdbStoreUpdateTest::store, nullptr);
75 }
76 
TearDownTestCase(void)77 void RdbStoreUpdateTest::TearDownTestCase(void)
78 {
79     store = nullptr;
80     RdbHelper::DeleteRdbStore(RdbStoreUpdateTest::DATABASE_NAME);
81 }
82 
SetUp(void)83 void RdbStoreUpdateTest::SetUp(void)
84 {
85     store->ExecuteSql("DELETE FROM test");
86 }
87 
TearDown(void)88 void RdbStoreUpdateTest::TearDown(void)
89 {
90     RdbHelper::ClearCache();
91 }
92 
93 /**
94  * @tc.name: RdbStore_Update_001
95  * @tc.desc: test RdbStore update, select id and update one row
96  * @tc.type: FUNC
97  */
98 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_001, TestSize.Level1)
99 {
100     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
101 
102     ValuesBucket values;
103     int changedRows;
104     int64_t id;
105 
106     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
107     EXPECT_EQ(ret, E_OK);
108     EXPECT_EQ(1, id);
109 
110     values.Clear();
111     values.PutInt("id", 2);
112     values.PutString("name", std::string("lisi"));
113     values.PutInt("age", 20);
114     values.PutDouble("salary", 200.5);
115     values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
116     ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
117     EXPECT_EQ(ret, E_OK);
118     EXPECT_EQ(1, changedRows);
119 
120     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
121     EXPECT_NE(resultSet, nullptr);
122 
123     ret = resultSet->GoToFirstRow();
124     EXPECT_EQ(ret, E_OK);
125     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
126 
127     ret = resultSet->GoToNextRow();
128     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
129 
130     ret = resultSet->Close();
131     EXPECT_EQ(ret, E_OK);
132 }
133 
134 /**
135  * @tc.name: RdbStore_Update_002
136  * @tc.desc: test RdbStore update, no select and update all rows
137  * @tc.type: FUNC
138  */
139 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_002, TestSize.Level1)
140 {
141     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
142 
143     int64_t id;
144     ValuesBucket values;
145     int changedRows;
146 
147     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
148     EXPECT_EQ(ret, E_OK);
149     EXPECT_EQ(1, id);
150 
151     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
152     EXPECT_EQ(ret, E_OK);
153     EXPECT_EQ(2, id);
154 
155     values.Clear();
156     values.PutDouble("salary", 300.5);
157     values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
158     ret = store->Update(changedRows, "test", values);
159     EXPECT_EQ(ret, E_OK);
160     EXPECT_EQ(2, changedRows);
161 
162     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
163     EXPECT_NE(resultSet, nullptr);
164 
165     ret = resultSet->GoToNextRow();
166     EXPECT_EQ(ret, E_OK);
167     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
168 
169     ret = resultSet->GoToNextRow();
170     EXPECT_EQ(ret, E_OK);
171     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
172 
173     ret = resultSet->GoToNextRow();
174     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
175 
176     ret = resultSet->Close();
177     EXPECT_EQ(ret, E_OK);
178 }
179 
180 /**
181  * @tc.name: RdbStore_Update_003
182  * @tc.desc: test RdbStore update
183  * @tc.type: FUNC
184  */
185 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_003, TestSize.Level1)
186 {
187     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
188 
189     int changedRows;
190     ValuesBucket values;
191     values.PutInt("id", 1);
192     values.PutString("name", std::string("zhangsan"));
193     values.PutInt("age", 18);
194     values.PutDouble("salary", 100.5);
195     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
196     int ret = store->Update(changedRows, "", values, "", std::vector<std::string>()); // empty table name
197     EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
198 
199     ret = store->Update(changedRows, "wrongTable", values, "", std::vector<std::string>()); // no such table
200     EXPECT_EQ(ret, E_SQLITE_ERROR);
201 }
202 
203 /**
204  * @tc.name: RdbStore_Update_004
205  * @tc.desc: test RdbStore insert
206  * @tc.type: FUNC
207  */
208 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_004, TestSize.Level1)
209 {
210     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
211 
212     int changedRows;
213     ValuesBucket emptyBucket;
214     int ret = store->Update(changedRows, "test", emptyBucket);
215     EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
216 
217     ValuesBucket values;
218     values.PutInt("id", 1);
219     values.PutString("name", std::string("zhangsan"));
220     values.PutInt("age", 18);
221     values.PutDouble("wrongColumn", 100.5); // no such column
222     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
223     ret = store->Update(changedRows, "test", values, "", std::vector<std::string>());
224     EXPECT_EQ(ret, E_SQLITE_ERROR);
225 }
226 
227 /**
228  * @tc.name: RdbStore_Update_005
229  * @tc.desc: test RdbStore insert
230  * @tc.type: FUNC
231  */
232 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_005, TestSize.Level1)
233 {
234     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
235 
236     ValuesBucket values;
237     int changedRows;
238     int64_t id;
239 
240     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
241     EXPECT_EQ(ret, E_OK);
242     EXPECT_EQ(1, id);
243 
244     ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
245     EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
246 }
247 
248 /**
249  * @tc.name: RdbStore_Update_006
250  * @tc.desc: test RdbStore insert
251  * @tc.type: FUNC
252  */
253 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_006, TestSize.Level1)
254 {
255     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
256 
257     ValuesBucket values;
258     int changedRows;
259     int64_t id;
260 
261     values.Clear();
262     values.PutString("id", "2");
263     values.PutString("name", std::string("lisi"));
264     values.PutInt("age", 20);
265     values.PutDouble("salary", 200.5);
266     values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
267     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
268     EXPECT_EQ(ret, E_OK);
269     EXPECT_EQ(1, id);
270 
271     ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
272     EXPECT_EQ(ret, E_OK);
273     EXPECT_EQ(1, changedRows);
274 
275     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
276     EXPECT_NE(resultSet, nullptr);
277 
278     ret = resultSet->GoToFirstRow();
279     EXPECT_EQ(ret, E_OK);
280     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
281 
282     ret = resultSet->GoToNextRow();
283     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
284 
285     ret = resultSet->Close();
286     EXPECT_EQ(ret, E_OK);
287 }
288 
289 /**
290  * @tc.name: RdbStore_UpdateWithConflictResolution_001
291  * @tc.desc: test RdbStore UpdateWithConflictResolution
292  * @tc.type: FUNC
293  */
294 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_001, TestSize.Level1)
295 {
296     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
297 
298     ValuesBucket values;
299     int changedRows;
300     int64_t id;
301 
302     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
303     EXPECT_EQ(ret, E_OK);
304     EXPECT_EQ(1, id);
305 
306     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
307     EXPECT_EQ(ret, E_OK);
308     EXPECT_EQ(2, id);
309 
310     // update lisi age=19 to wangjing age=20
311     values.PutInt("id", 3);
312     values.PutString("name", std::string("wangjing"));
313     values.PutInt("age", 20);
314     values.PutDouble("salary", 300.5);
315     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
316     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = 19");
317     EXPECT_EQ(ret, E_OK);
318     EXPECT_EQ(1, changedRows);
319 
320     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
321     EXPECT_NE(resultSet, nullptr);
322 
323     ret = resultSet->GoToNextRow();
324     EXPECT_EQ(ret, E_OK);
325     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
326 
327     ret = resultSet->GoToNextRow();
328     EXPECT_EQ(ret, E_OK);
329     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
330 
331     ret = resultSet->GoToNextRow();
332     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
333 
334     ret = resultSet->Close();
335     EXPECT_EQ(ret, E_OK);
336 }
337 
338 /**
339  * @tc.name: RdbStore_UpdateWithConflictResolution_002
340  * @tc.desc: test RdbStore UpdateWithConflictResolution
341  * @tc.type: FUNC
342  */
343 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize.Level1)
344 {
345     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
346 
347     ValuesBucket values;
348     int changedRows;
349     int64_t id;
350 
351     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
352     EXPECT_EQ(ret, E_OK);
353     EXPECT_EQ(1, id);
354 
355     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
356     EXPECT_EQ(ret, E_OK);
357     EXPECT_EQ(2, id);
358 
359     // update lisi age=19 to zhangsan age=20
360     values.PutInt("id", 3);
361     values.PutString("name", std::string("zhangsan"));
362     values.PutInt("age", 20);
363     values.PutDouble("salary", 300.5);
364     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
365     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
366         ConflictResolution::ON_CONFLICT_NONE);
367     EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
368 
369     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
370     EXPECT_NE(resultSet, nullptr);
371 
372     ret = resultSet->GoToNextRow();
373     EXPECT_EQ(ret, E_OK);
374     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
375 
376     ret = resultSet->GoToNextRow();
377     EXPECT_EQ(ret, E_OK);
378     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
379 
380     ret = resultSet->GoToNextRow();
381     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
382 
383     ret = resultSet->Close();
384     EXPECT_EQ(ret, E_OK);
385 }
386 
387 /**
388  * @tc.name: RdbStore_UpdateWithConflictResolution_003
389  * @tc.desc: test RdbStore UpdateWithConflictResolution
390  * @tc.type: FUNC
391  */
392 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize.Level1)
393 {
394     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
395 
396     ValuesBucket values;
397     int changedRows;
398     int64_t id;
399 
400     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
401     EXPECT_EQ(ret, E_OK);
402     EXPECT_EQ(1, id);
403 
404     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
405     EXPECT_EQ(ret, E_OK);
406     EXPECT_EQ(2, id);
407 
408     // update lisi age=19 to wangjing age=20
409     values.PutInt("id", 3);
410     values.PutString("name", std::string("wangjing"));
411     values.PutInt("age", 20);
412     values.PutDouble("salary", 300.5);
413     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
414     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
415         ConflictResolution::ON_CONFLICT_ROLLBACK);
416     EXPECT_EQ(ret, E_OK);
417     EXPECT_EQ(1, changedRows);
418 
419     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
420     EXPECT_NE(resultSet, nullptr);
421 
422     ret = resultSet->GoToNextRow();
423     EXPECT_EQ(ret, E_OK);
424     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
425 
426     ret = resultSet->GoToNextRow();
427     EXPECT_EQ(ret, E_OK);
428     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
429 
430     ret = resultSet->GoToNextRow();
431     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
432 
433     ret = resultSet->Close();
434     EXPECT_EQ(ret, E_OK);
435 }
436 
437 /**
438  * @tc.name: RdbStore_UpdateWithConflictResolution_004
439  * @tc.desc: test RdbStore UpdateWithConflictResolution
440  * @tc.type: FUNC
441  */
442 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize.Level1)
443 {
444     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
445 
446     ValuesBucket values;
447     int changedRows;
448     int64_t id;
449 
450     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
451     EXPECT_EQ(ret, E_OK);
452     EXPECT_EQ(1, id);
453 
454     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
455     EXPECT_EQ(ret, E_OK);
456     EXPECT_EQ(2, id);
457 
458     // update lisi age=19 to zhangsan age=20
459     values.PutInt("id", 3);
460     values.PutString("name", std::string("zhangsan"));
461     values.PutInt("age", 20);
462     values.PutDouble("salary", 300.5);
463     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
464     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
465         ConflictResolution::ON_CONFLICT_ROLLBACK);
466     EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
467 
468     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
469     EXPECT_NE(resultSet, nullptr);
470 
471     ret = resultSet->GoToNextRow();
472     EXPECT_EQ(ret, E_OK);
473     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
474 
475     ret = resultSet->GoToNextRow();
476     EXPECT_EQ(ret, E_OK);
477     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
478 
479     ret = resultSet->GoToNextRow();
480     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
481 
482     ret = resultSet->Close();
483     EXPECT_EQ(ret, E_OK);
484 }
485 
486 /**
487  * @tc.name: RdbStore_UpdateWithConflictResolution_005
488  * @tc.desc: test RdbStore UpdateWithConflictResolution
489  * @tc.type: FUNC
490  */
491 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize.Level1)
492 {
493     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
494 
495     ValuesBucket values;
496     int changedRows;
497     int64_t id;
498 
499     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
500     EXPECT_EQ(ret, E_OK);
501     EXPECT_EQ(1, id);
502 
503     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
504     EXPECT_EQ(ret, E_OK);
505     EXPECT_EQ(2, id);
506 
507     // update lisi age=19 to wangjing age=20
508     values.PutInt("id", 3);
509     values.PutString("name", std::string("wangjing"));
510     values.PutInt("age", 20);
511     values.PutDouble("salary", 300.5);
512     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
513     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
514         ConflictResolution::ON_CONFLICT_REPLACE);
515     EXPECT_EQ(ret, E_OK);
516     EXPECT_EQ(1, changedRows);
517 
518     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
519     EXPECT_NE(resultSet, nullptr);
520 
521     ret = resultSet->GoToNextRow();
522     EXPECT_EQ(ret, E_OK);
523     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
524 
525     ret = resultSet->GoToNextRow();
526     EXPECT_EQ(ret, E_OK);
527     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
528 
529     ret = resultSet->GoToNextRow();
530     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
531 
532     ret = resultSet->Close();
533     EXPECT_EQ(ret, E_OK);
534 }
535 
536 /**
537  * @tc.name: RdbStore_UpdateWithConflictResolution_006
538  * @tc.desc: test RdbStore UpdateWithConflictResolution
539  * @tc.type: FUNC
540  */
541 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize.Level1)
542 {
543     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
544 
545     ValuesBucket values;
546     int changedRows;
547     int64_t id;
548 
549     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
550     EXPECT_EQ(ret, E_OK);
551     EXPECT_EQ(1, id);
552 
553     ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
554     EXPECT_EQ(ret, E_OK);
555     EXPECT_EQ(2, id);
556 
557     // update lisi age=19 to zhangsan age=20
558     values.PutString("name", std::string("zhangsan"));
559     values.PutInt("age", 20);
560     values.PutDouble("salary", 300.5);
561     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
562         ConflictResolution::ON_CONFLICT_REPLACE);
563     EXPECT_EQ(ret, E_OK);
564     EXPECT_EQ(changedRows, 1);
565 
566     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
567     EXPECT_NE(resultSet, nullptr);
568 
569     ret = resultSet->GoToNextRow();
570     EXPECT_EQ(ret, E_OK);
571 
572     RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "zhangsan", 20, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
573 
574     ret = resultSet->GoToNextRow();
575     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
576 
577     ret = resultSet->Close();
578     EXPECT_EQ(ret, E_OK);
579 }
580 
581 /**
582  * @tc.name: RdbStore_UpdateWithConflictResolution_007
583  * @tc.desc: test RdbStore UpdateWithConflictResolution
584  * @tc.type: FUNC
585  */
586 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_007, TestSize.Level1)
587 {
588     std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
589 
590     int changedRows = 0;
591     int64_t id = -1;
592     ValuesBucket values;
593 
594     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
595     EXPECT_EQ(ret, E_OK);
596     EXPECT_EQ(1, id);
597 
598     values.PutInt("id", 2);
599     values.PutInt("age", 19);
600     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" },
601         static_cast<ConflictResolution>(6));
602     EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
603     EXPECT_EQ(0, changedRows);
604 
605     values.Clear();
606     values.PutInt("id", 2);
607     values.PutInt("age", 19);
608     ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" },
609         static_cast<ConflictResolution>(-1));
610     EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
611     EXPECT_EQ(0, changedRows);
612 }
613 
614 /**
615  * @tc.name: RdbStore_UpdateSqlBuilder_001
616  * @tc.desc: test RdbStore UpdateSqlBuilder
617  * @tc.type: FUNC
618  */
619 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateSqlBuilder_001, TestSize.Level1)
620 {
621     ValuesBucket values;
622     values.PutString("name", std::string("zhangsan"));
623     values.PutInt("age", 20);
624     values.PutDouble("salary", 300.5);
625 
626     std::vector<ValueObject> bindArgs;
627     std::string updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{ "19" }, "",
628         "age = ?", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
629     EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=? WHERE age = ?");
630 
631     updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{}, "", "", "", "",
632         INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
633     EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=?");
634 }
635 
ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> & resultSet,const RowData & expect)636 void RdbStoreUpdateTest::ExpectValue(
637     const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet, const RowData &expect)
638 {
639     EXPECT_NE(nullptr, resultSet);
640     int columnIndex;
641     int intVal;
642     int ret;
643 
644     if (expect.id != -1) {
645         ret = resultSet->GetColumnIndex("id", columnIndex);
646         EXPECT_EQ(ret, E_OK);
647         ret = resultSet->GetInt(columnIndex, intVal);
648         EXPECT_EQ(ret, E_OK);
649         EXPECT_EQ(expect.id, intVal);
650     }
651     if (expect.name != "") {
652         std::string strVal;
653         ret = resultSet->GetColumnIndex("name", columnIndex);
654         EXPECT_EQ(ret, E_OK);
655         ret = resultSet->GetString(columnIndex, strVal);
656         EXPECT_EQ(ret, E_OK);
657         EXPECT_EQ(expect.name, strVal);
658     }
659     if (expect.age != -1) {
660         ret = resultSet->GetColumnIndex("age", columnIndex);
661         EXPECT_EQ(ret, E_OK);
662         ret = resultSet->GetInt(columnIndex, intVal);
663         EXPECT_EQ(ret, E_OK);
664         EXPECT_EQ(expect.age, intVal);
665     }
666     if (expect.salary != -1) {
667         double dVal;
668         ret = resultSet->GetColumnIndex("salary", columnIndex);
669         EXPECT_EQ(ret, E_OK);
670         ret = resultSet->GetDouble(columnIndex, dVal);
671         EXPECT_EQ(ret, E_OK);
672         EXPECT_EQ(expect.salary, dVal);
673     }
674     if (expect.blobType.size() != 0) {
675         std::vector<uint8_t> blob;
676         ret = resultSet->GetColumnIndex("blobType", columnIndex);
677         EXPECT_EQ(ret, E_OK);
678         ret = resultSet->GetBlob(columnIndex, blob);
679         EXPECT_EQ(ret, E_OK);
680         EXPECT_EQ(expect.blobType.size(), static_cast<int>(blob.size()));
681         for (int i = 0; i < expect.blobType.size(); i++) {
682             EXPECT_EQ(expect.blobType[i], blob[i]);
683         }
684     }
685 }