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,
35 const RowData &expect);
36 void SetUp();
37 void TearDown();
38
39 static const std::string DATABASE_NAME;
40 static std::shared_ptr<RdbStore> store;
41 static const int E_SQLITE_ERROR; // errno SQLITE_ERROR
42 static const int E_SQLITE_CONSTRAINT; // errno SQLITE_CONSTRAINT
43 };
44
45 const std::string RdbStoreUpdateTest::DATABASE_NAME = RDB_TEST_PATH + "update_test.db";
46 std::shared_ptr<RdbStore> RdbStoreUpdateTest::store = nullptr;
47 const int RdbStoreUpdateTest::E_SQLITE_ERROR = -1; // errno SQLITE_ERROR
48 const int RdbStoreUpdateTest::E_SQLITE_CONSTRAINT = -19;
49
50 class UpdateTestOpenCallback : public RdbOpenCallback {
51 public:
52 int OnCreate(RdbStore &store) override;
53 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
54 static const std::string CREATE_TABLE_TEST;
55 };
56
57 const std::string UpdateTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
58 + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
59 "name TEXT UNIQUE, age INTEGER, salary "
60 "REAL, blobType BLOB)");
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 */
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 = ?",
122 std::vector<std::string>{ "1" });
123 EXPECT_EQ(ret, E_OK);
124 EXPECT_EQ(1, changedRows);
125
126 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
127 EXPECT_NE(resultSet, nullptr);
128
129 ret = resultSet->GoToFirstRow();
130 EXPECT_EQ(ret, E_OK);
131 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
132
133 ret = resultSet->GoToNextRow();
134 EXPECT_EQ(ret, E_ERROR);
135
136 ret = resultSet->Close();
137 EXPECT_EQ(ret, E_OK);
138 }
139
140 /**
141 * @tc.name: RdbStore_Update_002
142 * @tc.desc: test RdbStore update, no select and update all rows
143 * @tc.type: FUNC
144 */
145 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_002, TestSize.Level1)
146 {
147 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
148
149 int64_t id;
150 ValuesBucket values;
151 int changedRows;
152
153 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
154 EXPECT_EQ(ret, E_OK);
155 EXPECT_EQ(1, id);
156
157 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
158 EXPECT_EQ(ret, E_OK);
159 EXPECT_EQ(2, id);
160
161 values.Clear();
162 values.PutDouble("salary", 300.5);
163 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
164 ret = store->Update(changedRows, "test", values);
165 EXPECT_EQ(ret, E_OK);
166 EXPECT_EQ(2, changedRows);
167
168 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
169 EXPECT_NE(resultSet, nullptr);
170
171 ret = resultSet->GoToNextRow();
172 EXPECT_EQ(ret, E_OK);
173 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 300.5, std::vector<uint8_t>{ 4, 5, 6 }});
174
175 ret = resultSet->GoToNextRow();
176 EXPECT_EQ(ret, E_OK);
177 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 19, 300.5, std::vector<uint8_t>{ 4, 5, 6 }});
178
179 ret = resultSet->GoToNextRow();
180 EXPECT_EQ(ret, E_ERROR);
181
182 ret = resultSet->Close();
183 EXPECT_EQ(ret, E_OK);
184 }
185
186 /**
187 * @tc.name: RdbStore_Update_003
188 * @tc.desc: test RdbStore update
189 * @tc.type: FUNC
190 */
191 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_003, TestSize.Level1)
192 {
193 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
194
195 int changedRows;
196 ValuesBucket values;
197 values.PutInt("id", 1);
198 values.PutString("name", std::string("zhangsan"));
199 values.PutInt("age", 18);
200 values.PutDouble("salary", 100.5);
201 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
202 int ret = store->Update(changedRows, "", values, "", std::vector<std::string>()); // empty table name
203 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
204
205 ret = store->Update(changedRows, "wrongTable", values, "", std::vector<std::string>()); // no such table
206 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_ERROR);
207 }
208
209 /**
210 * @tc.name: RdbStore_Update_004
211 * @tc.desc: test RdbStore insert
212 * @tc.type: FUNC
213 */
214 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_004, TestSize.Level1)
215 {
216 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
217
218 int changedRows;
219 ValuesBucket emptyBucket;
220 int ret = store->Update(changedRows, "test", emptyBucket);
221 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
222
223 ValuesBucket values;
224 values.PutInt("id", 1);
225 values.PutString("name", std::string("zhangsan"));
226 values.PutInt("age", 18);
227 values.PutDouble("wrongColumn", 100.5); // no such column
228 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
229 ret = store->Update(changedRows, "test", values, "", std::vector<std::string>());
230 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_ERROR);
231 }
232
233 /**
234 * @tc.name: RdbStore_UpdateWithConflictResolution_001
235 * @tc.desc: test RdbStore UpdateWithConflictResolution
236 * @tc.type: FUNC
237 */
238 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_001, TestSize.Level1)
239 {
240 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
241
242 ValuesBucket values;
243 int changedRows;
244 int64_t id;
245
246 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
247 EXPECT_EQ(ret, E_OK);
248 EXPECT_EQ(1, id);
249
250 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
251 EXPECT_EQ(ret, E_OK);
252 EXPECT_EQ(2, id);
253
254 // update lisi age=19 to wangjing age=20
255 values.PutInt("id", 3);
256 values.PutString("name", std::string("wangjing"));
257 values.PutInt("age", 20);
258 values.PutDouble("salary", 300.5);
259 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
260 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = 19");
261 EXPECT_EQ(ret, E_OK);
262 EXPECT_EQ(1, changedRows);
263
264 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
265 EXPECT_NE(resultSet, nullptr);
266
267 ret = resultSet->GoToNextRow();
268 EXPECT_EQ(ret, E_OK);
269 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
270
271 ret = resultSet->GoToNextRow();
272 EXPECT_EQ(ret, E_OK);
273 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 }});
274
275 ret = resultSet->GoToNextRow();
276 EXPECT_EQ(ret, E_ERROR);
277
278 ret = resultSet->Close();
279 EXPECT_EQ(ret, E_OK);
280 }
281
282 /**
283 * @tc.name: RdbStore_UpdateWithConflictResolution_002
284 * @tc.desc: test RdbStore UpdateWithConflictResolution
285 * @tc.type: FUNC
286 */
287 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize.Level1)
288 {
289 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
290
291 ValuesBucket values;
292 int changedRows;
293 int64_t id;
294
295 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
296 EXPECT_EQ(ret, E_OK);
297 EXPECT_EQ(1, id);
298
299 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
300 EXPECT_EQ(ret, E_OK);
301 EXPECT_EQ(2, id);
302
303 // update lisi age=19 to zhangsan age=20
304 values.PutInt("id", 3);
305 values.PutString("name", std::string("zhangsan"));
306 values.PutInt("age", 20);
307 values.PutDouble("salary", 300.5);
308 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
309 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
310 std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_NONE);
311 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_CONSTRAINT);
312
313 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
314 EXPECT_NE(resultSet, nullptr);
315
316 ret = resultSet->GoToNextRow();
317 EXPECT_EQ(ret, E_OK);
318 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
319
320 ret = resultSet->GoToNextRow();
321 EXPECT_EQ(ret, E_OK);
322 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
323
324 ret = resultSet->GoToNextRow();
325 EXPECT_EQ(ret, E_ERROR);
326
327 ret = resultSet->Close();
328 EXPECT_EQ(ret, E_OK);
329 }
330
331 /**
332 * @tc.name: RdbStore_UpdateWithConflictResolution_003
333 * @tc.desc: test RdbStore UpdateWithConflictResolution
334 * @tc.type: FUNC
335 */
336 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize.Level1)
337 {
338 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
339
340 ValuesBucket values;
341 int changedRows;
342 int64_t id;
343
344 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
345 EXPECT_EQ(ret, E_OK);
346 EXPECT_EQ(1, id);
347
348 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
349 EXPECT_EQ(ret, E_OK);
350 EXPECT_EQ(2, id);
351
352 // update lisi age=19 to wangjing age=20
353 values.PutInt("id", 3);
354 values.PutString("name", std::string("wangjing"));
355 values.PutInt("age", 20);
356 values.PutDouble("salary", 300.5);
357 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
358 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
359 std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_ROLLBACK);
360 EXPECT_EQ(ret, E_OK);
361 EXPECT_EQ(1, changedRows);
362
363 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
364 EXPECT_NE(resultSet, nullptr);
365
366 ret = resultSet->GoToNextRow();
367 EXPECT_EQ(ret, E_OK);
368 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
369
370 ret = resultSet->GoToNextRow();
371 EXPECT_EQ(ret, E_OK);
372 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 }});
373
374 ret = resultSet->GoToNextRow();
375 EXPECT_EQ(ret, E_ERROR);
376
377 ret = resultSet->Close();
378 EXPECT_EQ(ret, E_OK);
379 }
380
381 /**
382 * @tc.name: RdbStore_UpdateWithConflictResolution_004
383 * @tc.desc: test RdbStore UpdateWithConflictResolution
384 * @tc.type: FUNC
385 */
386 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize.Level1)
387 {
388 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
389
390 ValuesBucket values;
391 int changedRows;
392 int64_t id;
393
394 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
395 EXPECT_EQ(ret, E_OK);
396 EXPECT_EQ(1, id);
397
398 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
399 EXPECT_EQ(ret, E_OK);
400 EXPECT_EQ(2, id);
401
402 // update lisi age=19 to zhangsan age=20
403 values.PutInt("id", 3);
404 values.PutString("name", std::string("zhangsan"));
405 values.PutInt("age", 20);
406 values.PutDouble("salary", 300.5);
407 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
408 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
409 std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_ROLLBACK);
410 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_CONSTRAINT);
411
412 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
413 EXPECT_NE(resultSet, nullptr);
414
415 ret = resultSet->GoToNextRow();
416 EXPECT_EQ(ret, E_OK);
417 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
418
419 ret = resultSet->GoToNextRow();
420 EXPECT_EQ(ret, E_OK);
421 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
422
423 ret = resultSet->GoToNextRow();
424 EXPECT_EQ(ret, E_ERROR);
425
426 ret = resultSet->Close();
427 EXPECT_EQ(ret, E_OK);
428 }
429
430 /**
431 * @tc.name: RdbStore_UpdateWithConflictResolution_005
432 * @tc.desc: test RdbStore UpdateWithConflictResolution
433 * @tc.type: FUNC
434 */
435 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize.Level1)
436 {
437 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
438
439 ValuesBucket values;
440 int changedRows;
441 int64_t id;
442
443 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
444 EXPECT_EQ(ret, E_OK);
445 EXPECT_EQ(1, id);
446
447 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
448 EXPECT_EQ(ret, E_OK);
449 EXPECT_EQ(2, id);
450
451 // update lisi age=19 to wangjing age=20
452 values.PutInt("id", 3);
453 values.PutString("name", std::string("wangjing"));
454 values.PutInt("age", 20);
455 values.PutDouble("salary", 300.5);
456 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
457 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
458 std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_REPLACE);
459 EXPECT_EQ(ret, E_OK);
460 EXPECT_EQ(1, changedRows);
461
462 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
463 EXPECT_NE(resultSet, nullptr);
464
465 ret = resultSet->GoToNextRow();
466 EXPECT_EQ(ret, E_OK);
467 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
468
469 ret = resultSet->GoToNextRow();
470 EXPECT_EQ(ret, E_OK);
471 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 }});
472
473 ret = resultSet->GoToNextRow();
474 EXPECT_EQ(ret, E_ERROR);
475
476 ret = resultSet->Close();
477 EXPECT_EQ(ret, E_OK);
478 }
479
480 /**
481 * @tc.name: RdbStore_UpdateWithConflictResolution_006
482 * @tc.desc: test RdbStore UpdateWithConflictResolution
483 * @tc.type: FUNC
484 */
485 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize.Level1)
486 {
487 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
488
489 ValuesBucket values;
490 int changedRows;
491 int64_t id;
492
493 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
494 EXPECT_EQ(ret, E_OK);
495 EXPECT_EQ(1, id);
496
497 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
498 EXPECT_EQ(ret, E_OK);
499 EXPECT_EQ(2, id);
500
501 // update lisi age=19 to zhangsan age=20
502 values.PutString("name", std::string("zhangsan"));
503 values.PutInt("age", 20);
504 values.PutDouble("salary", 300.5);
505 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
506 std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_REPLACE);
507 EXPECT_EQ(ret, E_OK);
508 EXPECT_EQ(changedRows, 1);
509
510 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
511 EXPECT_NE(resultSet, nullptr);
512
513 ret = resultSet->GoToNextRow();
514 EXPECT_EQ(ret, E_OK);
515
516 RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "zhangsan", 20, 300.5, std::vector<uint8_t>{ 4, 5, 6 }});
517
518 ret = resultSet->GoToNextRow();
519 EXPECT_EQ(ret, E_ERROR);
520
521 ret = resultSet->Close();
522 EXPECT_EQ(ret, E_OK);
523 }
524
525 /**
526 * @tc.name: RdbStore_UpdateSqlBuilder_001
527 * @tc.desc: test RdbStore UpdateSqlBuilder
528 * @tc.type: FUNC
529 */
530 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateSqlBuilder_001, TestSize.Level1)
531 {
532 ValuesBucket values;
533 values.PutString("name", std::string("zhangsan"));
534 values.PutInt("age", 20);
535 values.PutDouble("salary", 300.5);
536
537 std::vector<ValueObject> bindArgs;
538 std::string updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{ "19" },
539 "", "age = ?", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
540 EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=? WHERE age = ?");
541
542 updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{},
543 "", "", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
544 EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=?");
545 }
546
ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> & resultSet,const RowData & expect)547 void RdbStoreUpdateTest::ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet,
548 const RowData &expect)
549 {
550 EXPECT_NE(nullptr, resultSet);
551 int columnIndex;
552 int intVal;
553 int ret;
554
555 if (expect.id != -1) {
556 ret = resultSet->GetColumnIndex("id", columnIndex);
557 EXPECT_EQ(ret, E_OK);
558 ret = resultSet->GetInt(columnIndex, intVal);
559 EXPECT_EQ(ret, E_OK);
560 EXPECT_EQ(expect.id, intVal);
561 }
562 if (expect.name != "") {
563 std::string strVal;
564 ret = resultSet->GetColumnIndex("name", columnIndex);
565 EXPECT_EQ(ret, E_OK);
566 ret = resultSet->GetString(columnIndex, strVal);
567 EXPECT_EQ(ret, E_OK);
568 EXPECT_EQ(expect.name, strVal);
569 }
570 if (expect.age != -1) {
571 ret = resultSet->GetColumnIndex("age", columnIndex);
572 EXPECT_EQ(ret, E_OK);
573 ret = resultSet->GetInt(columnIndex, intVal);
574 EXPECT_EQ(ret, E_OK);
575 EXPECT_EQ(expect.age, intVal);
576 }
577 if (expect.salary != -1) {
578 double dVal;
579 ret = resultSet->GetColumnIndex("salary", columnIndex);
580 EXPECT_EQ(ret, E_OK);
581 ret = resultSet->GetDouble(columnIndex, dVal);
582 EXPECT_EQ(ret, E_OK);
583 EXPECT_EQ(expect.salary, dVal);
584 }
585 if (expect.blobType.size() != 0) {
586 std::vector<uint8_t> blob;
587 ret = resultSet->GetColumnIndex("blobType", columnIndex);
588 EXPECT_EQ(ret, E_OK);
589 ret = resultSet->GetBlob(columnIndex, blob);
590 EXPECT_EQ(ret, E_OK);
591 EXPECT_EQ(expect.blobType.size(), static_cast<int>(blob.size()));
592 for (int i = 0; i < expect.blobType.size(); i++) {
593 EXPECT_EQ(expect.blobType[i], blob[i]);
594 }
595 }
596 }