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 "logger.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28
29 class RdbStoreUpdateTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35
36 static const std::string DATABASE_NAME;
37 static std::shared_ptr<RdbStore> store;
38 static const int E_SQLITE_ERROR; // errno SQLITE_ERROR
39 static const int E_SQLITE_CONSTRAINT; // errno SQLITE_CONSTRAINT
40 };
41
42 const std::string RdbStoreUpdateTest::DATABASE_NAME = RDB_TEST_PATH + "update_test.db";
43 std::shared_ptr<RdbStore> RdbStoreUpdateTest::store = nullptr;
44 const int RdbStoreUpdateTest::E_SQLITE_ERROR = -1; // errno SQLITE_ERROR
45 const int RdbStoreUpdateTest::E_SQLITE_CONSTRAINT = -19;
46
47 class UpdateTestOpenCallback : public RdbOpenCallback {
48 public:
49 int OnCreate(RdbStore &rdbStore) override;
50 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
51 static const std::string CREATE_TABLE_TEST;
52 };
53
54 const std::string UpdateTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
55 + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
56 "name TEXT UNIQUE, age INTEGER, salary "
57 "REAL, blobType BLOB)");
58
OnCreate(RdbStore & store)59 int UpdateTestOpenCallback::OnCreate(RdbStore &store)
60 {
61 return store.ExecuteSql(CREATE_TABLE_TEST);
62 }
63
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)64 int UpdateTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
65 {
66 return E_OK;
67 }
68
SetUpTestCase(void)69 void RdbStoreUpdateTest::SetUpTestCase(void)
70 {
71 int errCode = E_OK;
72 RdbStoreConfig config(RdbStoreUpdateTest::DATABASE_NAME);
73 UpdateTestOpenCallback helper;
74 RdbStoreUpdateTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
75 EXPECT_NE(RdbStoreUpdateTest::store, nullptr);
76 }
77
TearDownTestCase(void)78 void RdbStoreUpdateTest::TearDownTestCase(void)
79 {
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 * @tc.require: AR000CU2BO
98 * @tc.author: chenxi
99 */
100 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_001, TestSize.Level1)
101 {
102 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
103
104 int64_t id;
105 ValuesBucket values;
106 int changedRows;
107
108 values.PutInt("id", 1);
109 values.PutString("name", std::string("zhangsan"));
110 values.PutInt("age", 18);
111 values.PutDouble("salary", 100.5);
112 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
113 int ret = store->Insert(id, "test", values);
114 EXPECT_EQ(ret, E_OK);
115 EXPECT_EQ(1, id);
116
117 values.Clear();
118 values.PutInt("id", 2);
119 values.PutString("name", std::string("lisi"));
120 values.PutInt("age", 20);
121 values.PutDouble("salary", 200.5);
122 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
123 ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
124 EXPECT_EQ(ret, E_OK);
125 EXPECT_EQ(1, changedRows);
126
127 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
128 EXPECT_NE(resultSet, nullptr);
129
130 int columnIndex;
131 int intVal;
132 std::string strVal;
133 double dVal;
134 std::vector<uint8_t> blob;
135
136 ret = resultSet->GoToFirstRow();
137 EXPECT_EQ(ret, E_OK);
138
139 ret = resultSet->GetColumnIndex("id", columnIndex);
140 EXPECT_EQ(ret, E_OK);
141 ret = resultSet->GetInt(columnIndex, intVal);
142 EXPECT_EQ(ret, E_OK);
143 EXPECT_EQ(2, intVal);
144
145 ret = resultSet->GetColumnIndex("name", columnIndex);
146 EXPECT_EQ(ret, E_OK);
147 ret = resultSet->GetString(columnIndex, strVal);
148 EXPECT_EQ(ret, E_OK);
149 EXPECT_EQ("lisi", strVal);
150
151 ret = resultSet->GetColumnIndex("age", columnIndex);
152 EXPECT_EQ(ret, E_OK);
153 ret = resultSet->GetInt(columnIndex, intVal);
154 EXPECT_EQ(ret, E_OK);
155 EXPECT_EQ(20, intVal);
156
157 ret = resultSet->GetColumnIndex("salary", columnIndex);
158 EXPECT_EQ(ret, E_OK);
159 ret = resultSet->GetDouble(columnIndex, dVal);
160 EXPECT_EQ(ret, E_OK);
161 EXPECT_EQ(200.5, dVal);
162
163 ret = resultSet->GetColumnIndex("blobType", columnIndex);
164 EXPECT_EQ(ret, E_OK);
165 ret = resultSet->GetBlob(columnIndex, blob);
166 EXPECT_EQ(ret, E_OK);
167 EXPECT_EQ(3, static_cast<int>(blob.size()));
168 EXPECT_EQ(4, blob[0]);
169 EXPECT_EQ(5, blob[1]);
170 EXPECT_EQ(6, blob[2]);
171
172 ret = resultSet->GoToNextRow();
173 EXPECT_EQ(ret, E_ERROR);
174
175 ret = resultSet->Close();
176 EXPECT_EQ(ret, E_OK);
177 }
178
179 /**
180 * @tc.name: RdbStore_Update_002
181 * @tc.desc: test RdbStore update, no select and update all rows
182 * @tc.type: FUNC
183 * @tc.require: AR000CU2BO
184 * @tc.author: chenxi
185 */
186 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_002, TestSize.Level1)
187 {
188 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
189
190 int64_t id;
191 ValuesBucket values;
192 int changedRows;
193
194 values.PutInt("id", 1);
195 values.PutString("name", std::string("zhangsan"));
196 values.PutInt("age", 18);
197 values.PutDouble("salary", 100.5);
198 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
199 int ret = store->Insert(id, "test", values);
200 EXPECT_EQ(ret, E_OK);
201 EXPECT_EQ(1, id);
202
203 values.Clear();
204 values.PutInt("id", 2);
205 values.PutString("name", std::string("lisi"));
206 values.PutInt("age", 20);
207 values.PutDouble("salary", 200.5);
208 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
209 ret = store->Insert(id, "test", values);
210 EXPECT_EQ(ret, E_OK);
211 EXPECT_EQ(2, id);
212
213 values.Clear();
214 values.PutDouble("salary", 300.5);
215 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
216 ret = store->Update(changedRows, "test", values);
217 EXPECT_EQ(ret, E_OK);
218 EXPECT_EQ(2, changedRows);
219
220 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
221 EXPECT_NE(resultSet, nullptr);
222
223 int columnIndex;
224 int intVal;
225 std::string strVal;
226 double dVal;
227 std::vector<uint8_t> blob;
228
229 ret = resultSet->GoToNextRow();
230 EXPECT_EQ(ret, E_OK);
231
232 ret = resultSet->GetColumnIndex("id", columnIndex);
233 EXPECT_EQ(ret, E_OK);
234 ret = resultSet->GetInt(columnIndex, intVal);
235 EXPECT_EQ(ret, E_OK);
236 EXPECT_EQ(1, intVal);
237
238 ret = resultSet->GetColumnIndex("name", columnIndex);
239 EXPECT_EQ(ret, E_OK);
240 ret = resultSet->GetString(columnIndex, strVal);
241 EXPECT_EQ(ret, E_OK);
242 EXPECT_EQ("zhangsan", strVal);
243 ret = resultSet->GetColumnIndex("age", columnIndex);
244 EXPECT_EQ(ret, E_OK);
245 ret = resultSet->GetInt(columnIndex, intVal);
246 EXPECT_EQ(ret, E_OK);
247 EXPECT_EQ(18, intVal);
248 ret = resultSet->GetColumnIndex("salary", columnIndex);
249 EXPECT_EQ(ret, E_OK);
250 ret = resultSet->GetDouble(columnIndex, dVal);
251 EXPECT_EQ(ret, E_OK);
252 EXPECT_EQ(300.5, dVal);
253
254 ret = resultSet->GetColumnIndex("blobType", columnIndex);
255 EXPECT_EQ(ret, E_OK);
256 ret = resultSet->GetBlob(columnIndex, blob);
257 EXPECT_EQ(ret, E_OK);
258 EXPECT_EQ(3, static_cast<int>(blob.size()));
259 EXPECT_EQ(4, blob[0]);
260 EXPECT_EQ(5, blob[1]);
261 EXPECT_EQ(6, blob[2]);
262
263 ret = resultSet->GoToNextRow();
264 EXPECT_EQ(ret, E_OK);
265 ret = resultSet->GetColumnIndex("id", columnIndex);
266 EXPECT_EQ(ret, E_OK);
267 ret = resultSet->GetInt(columnIndex, intVal);
268 EXPECT_EQ(ret, E_OK);
269 EXPECT_EQ(2, intVal);
270 ret = resultSet->GetColumnIndex("name", columnIndex);
271 EXPECT_EQ(ret, E_OK);
272 ret = resultSet->GetString(columnIndex, strVal);
273 EXPECT_EQ(ret, E_OK);
274 EXPECT_EQ("lisi", strVal);
275 ret = resultSet->GetColumnIndex("age", columnIndex);
276 EXPECT_EQ(ret, E_OK);
277 ret = resultSet->GetInt(columnIndex, intVal);
278 EXPECT_EQ(ret, E_OK);
279 EXPECT_EQ(20, intVal);
280 ret = resultSet->GetColumnIndex("salary", columnIndex);
281 EXPECT_EQ(ret, E_OK);
282 ret = resultSet->GetDouble(columnIndex, dVal);
283 EXPECT_EQ(ret, E_OK);
284 EXPECT_EQ(300.5, dVal);
285 ret = resultSet->GetColumnIndex("blobType", columnIndex);
286 EXPECT_EQ(ret, E_OK);
287 ret = resultSet->GetBlob(columnIndex, blob);
288 EXPECT_EQ(ret, E_OK);
289 EXPECT_EQ(3, static_cast<int>(blob.size()));
290 EXPECT_EQ(4, blob[0]);
291 EXPECT_EQ(5, blob[1]);
292 EXPECT_EQ(6, blob[2]);
293
294 ret = resultSet->GoToNextRow();
295 EXPECT_EQ(ret, E_ERROR);
296
297 ret = resultSet->Close();
298 EXPECT_EQ(ret, E_OK);
299 }
300
301 /**
302 * @tc.name: RdbStore_Update_003
303 * @tc.desc: test RdbStore update
304 * @tc.type: FUNC
305 * @tc.require: AR000CU2BO
306 * @tc.author: chenxi
307 */
308 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_003, TestSize.Level1)
309 {
310 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
311
312 int changedRows;
313 ValuesBucket values;
314 values.PutInt("id", 1);
315 values.PutString("name", std::string("zhangsan"));
316 values.PutInt("age", 18);
317 values.PutDouble("salary", 100.5);
318 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
319 int ret = store->Update(changedRows, "", values, "", std::vector<std::string>()); // empty table name
320 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
321
322 ret = store->Update(changedRows, "wrongTable", values, "", std::vector<std::string>()); // no such table
323 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_ERROR);
324 }
325
326 /**
327 * @tc.name: RdbStore_Update_004
328 * @tc.desc: test RdbStore insert
329 * @tc.type: FUNC
330 * @tc.require: AR000CU2BO
331 * @tc.author: chenxi
332 */
333 HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_004, TestSize.Level1)
334 {
335 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
336
337 int changedRows;
338 ValuesBucket emptyBucket;
339 int ret = store->Update(changedRows, "test", emptyBucket);
340 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
341
342 ValuesBucket values;
343 values.PutInt("id", 1);
344 values.PutString("name", std::string("zhangsan"));
345 values.PutInt("age", 18);
346 values.PutDouble("wrongColumn", 100.5); // no such column
347 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
348 ret = store->Update(changedRows, "test", values, "", std::vector<std::string>());
349 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_ERROR);
350 }
351
352 /**
353 * @tc.name: RdbStore_UpdateWithConflictResolution_001
354 * @tc.desc: test RdbStore UpdateWithConflictResolution
355 * @tc.type: FUNC
356 * @tc.require: AR000CU2BO
357 * @tc.author: chenxi
358 */
359 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_001, TestSize.Level1)
360 {
361 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
362
363 int64_t id;
364 ValuesBucket values;
365 int changedRows;
366
367 values.PutInt("id", 1);
368 values.PutString("name", std::string("zhangsan"));
369 values.PutInt("age", 18);
370 values.PutDouble("salary", 100.5);
371 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
372 int ret = store->Insert(id, "test", values);
373 EXPECT_EQ(ret, E_OK);
374 EXPECT_EQ(1, id);
375
376 values.Clear();
377 values.PutInt("id", 2);
378 values.PutString("name", std::string("lisi"));
379 values.PutInt("age", 19);
380 values.PutDouble("salary", 200.5);
381 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
382 ret = store->Insert(id, "test", values);
383 EXPECT_EQ(ret, E_OK);
384 EXPECT_EQ(2, id);
385
386 // update lisi age=19 to wangjing age=20
387 values.Clear();
388 values.PutInt("id", 3);
389 values.PutString("name", std::string("wangjing"));
390 values.PutInt("age", 20);
391 values.PutDouble("salary", 300.5);
392 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
393 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = 19");
394 EXPECT_EQ(ret, E_OK);
395 EXPECT_EQ(1, changedRows);
396
397 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
398 EXPECT_NE(resultSet, nullptr);
399
400 int columnIndex;
401 int intVal;
402 std::string strVal;
403 double dVal;
404 std::vector<uint8_t> blob;
405
406 ret = resultSet->GoToNextRow();
407 EXPECT_EQ(ret, E_OK);
408 ret = resultSet->GetColumnIndex("id", columnIndex);
409 EXPECT_EQ(ret, E_OK);
410 ret = resultSet->GetInt(columnIndex, intVal);
411 EXPECT_EQ(ret, E_OK);
412 EXPECT_EQ(1, intVal);
413 ret = resultSet->GetColumnIndex("name", columnIndex);
414 EXPECT_EQ(ret, E_OK);
415 ret = resultSet->GetString(columnIndex, strVal);
416 EXPECT_EQ(ret, E_OK);
417 EXPECT_EQ("zhangsan", strVal);
418 ret = resultSet->GetColumnIndex("age", columnIndex);
419 EXPECT_EQ(ret, E_OK);
420 ret = resultSet->GetInt(columnIndex, intVal);
421 EXPECT_EQ(ret, E_OK);
422 EXPECT_EQ(18, intVal);
423 ret = resultSet->GetColumnIndex("salary", columnIndex);
424 EXPECT_EQ(ret, E_OK);
425 ret = resultSet->GetDouble(columnIndex, dVal);
426 EXPECT_EQ(ret, E_OK);
427 EXPECT_EQ(100.5, dVal);
428 ret = resultSet->GetColumnIndex("blobType", columnIndex);
429 EXPECT_EQ(ret, E_OK);
430 ret = resultSet->GetBlob(columnIndex, blob);
431 EXPECT_EQ(ret, E_OK);
432 EXPECT_EQ(3, static_cast<int>(blob.size()));
433 EXPECT_EQ(1, blob[0]);
434 EXPECT_EQ(2, blob[1]);
435 EXPECT_EQ(3, blob[2]);
436
437 ret = resultSet->GoToNextRow();
438 EXPECT_EQ(ret, E_OK);
439 ret = resultSet->GetColumnIndex("id", columnIndex);
440 EXPECT_EQ(ret, E_OK);
441 ret = resultSet->GetInt(columnIndex, intVal);
442 EXPECT_EQ(ret, E_OK);
443 EXPECT_EQ(3, intVal);
444 ret = resultSet->GetColumnIndex("name", columnIndex);
445 EXPECT_EQ(ret, E_OK);
446 ret = resultSet->GetString(columnIndex, strVal);
447 EXPECT_EQ(ret, E_OK);
448 EXPECT_EQ("wangjing", strVal);
449 ret = resultSet->GetColumnIndex("age", columnIndex);
450 EXPECT_EQ(ret, E_OK);
451 ret = resultSet->GetInt(columnIndex, intVal);
452 EXPECT_EQ(ret, E_OK);
453 EXPECT_EQ(20, intVal);
454 ret = resultSet->GetColumnIndex("salary", columnIndex);
455 EXPECT_EQ(ret, E_OK);
456 ret = resultSet->GetDouble(columnIndex, dVal);
457 EXPECT_EQ(ret, E_OK);
458 EXPECT_EQ(300.5, dVal);
459 ret = resultSet->GetColumnIndex("blobType", columnIndex);
460 EXPECT_EQ(ret, E_OK);
461 ret = resultSet->GetBlob(columnIndex, blob);
462 EXPECT_EQ(ret, E_OK);
463 EXPECT_EQ(3, static_cast<int>(blob.size()));
464 EXPECT_EQ(7, blob[0]);
465 EXPECT_EQ(8, blob[1]);
466 EXPECT_EQ(9, blob[2]);
467
468 ret = resultSet->GoToNextRow();
469 EXPECT_EQ(ret, E_ERROR);
470
471 ret = resultSet->Close();
472 EXPECT_EQ(ret, E_OK);
473 }
474
475 /**
476 * @tc.name: RdbStore_UpdateWithConflictResolution_002
477 * @tc.desc: test RdbStore UpdateWithConflictResolution
478 * @tc.type: FUNC
479 * @tc.require: AR000CU2BO
480 * @tc.author: chenxi
481 */
482 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize.Level1)
483 {
484 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
485
486 int64_t id;
487 ValuesBucket values;
488 int changedRows;
489
490 values.PutInt("id", 1);
491 values.PutString("name", std::string("zhangsan"));
492 values.PutInt("age", 18);
493 values.PutDouble("salary", 100.5);
494 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
495 int ret = store->Insert(id, "test", values);
496 EXPECT_EQ(ret, E_OK);
497 EXPECT_EQ(1, id);
498
499 values.Clear();
500 values.PutInt("id", 2);
501 values.PutString("name", std::string("lisi"));
502 values.PutInt("age", 19);
503 values.PutDouble("salary", 200.5);
504 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
505 ret = store->Insert(id, "test", values);
506 EXPECT_EQ(ret, E_OK);
507 EXPECT_EQ(2, id);
508
509 // update lisi age=19 to zhangsan age=20
510 values.Clear();
511 values.PutInt("id", 3);
512 values.PutString("name", std::string("zhangsan"));
513 values.PutInt("age", 20);
514 values.PutDouble("salary", 300.5);
515 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
516 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
517 ConflictResolution::ON_CONFLICT_NONE);
518 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_CONSTRAINT);
519
520 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
521 EXPECT_NE(resultSet, nullptr);
522
523 int columnIndex;
524 int intVal;
525 std::string strVal;
526 double dVal;
527 std::vector<uint8_t> blob;
528
529 ret = resultSet->GoToNextRow();
530 EXPECT_EQ(ret, E_OK);
531 ret = resultSet->GetColumnIndex("id", columnIndex);
532 EXPECT_EQ(ret, E_OK);
533 ret = resultSet->GetInt(columnIndex, intVal);
534 EXPECT_EQ(ret, E_OK);
535 EXPECT_EQ(1, intVal);
536 ret = resultSet->GetColumnIndex("name", columnIndex);
537 EXPECT_EQ(ret, E_OK);
538 ret = resultSet->GetString(columnIndex, strVal);
539 EXPECT_EQ(ret, E_OK);
540 EXPECT_EQ("zhangsan", strVal);
541 ret = resultSet->GetColumnIndex("age", columnIndex);
542 EXPECT_EQ(ret, E_OK);
543 ret = resultSet->GetInt(columnIndex, intVal);
544 EXPECT_EQ(ret, E_OK);
545 EXPECT_EQ(18, intVal);
546 ret = resultSet->GetColumnIndex("salary", columnIndex);
547 EXPECT_EQ(ret, E_OK);
548 ret = resultSet->GetDouble(columnIndex, dVal);
549 EXPECT_EQ(ret, E_OK);
550 EXPECT_EQ(100.5, dVal);
551 ret = resultSet->GetColumnIndex("blobType", columnIndex);
552 EXPECT_EQ(ret, E_OK);
553 ret = resultSet->GetBlob(columnIndex, blob);
554 EXPECT_EQ(ret, E_OK);
555 EXPECT_EQ(3, static_cast<int>(blob.size()));
556 EXPECT_EQ(1, blob[0]);
557 EXPECT_EQ(2, blob[1]);
558 EXPECT_EQ(3, blob[2]);
559
560 ret = resultSet->GoToNextRow();
561 EXPECT_EQ(ret, E_OK);
562 ret = resultSet->GetColumnIndex("id", columnIndex);
563 EXPECT_EQ(ret, E_OK);
564 ret = resultSet->GetInt(columnIndex, intVal);
565 EXPECT_EQ(ret, E_OK);
566 EXPECT_EQ(2, intVal);
567 ret = resultSet->GetColumnIndex("name", columnIndex);
568 EXPECT_EQ(ret, E_OK);
569 ret = resultSet->GetString(columnIndex, strVal);
570 EXPECT_EQ(ret, E_OK);
571 EXPECT_EQ("lisi", strVal);
572 ret = resultSet->GetColumnIndex("age", columnIndex);
573 EXPECT_EQ(ret, E_OK);
574 ret = resultSet->GetInt(columnIndex, intVal);
575 EXPECT_EQ(ret, E_OK);
576 EXPECT_EQ(19, intVal);
577 ret = resultSet->GetColumnIndex("salary", columnIndex);
578 EXPECT_EQ(ret, E_OK);
579 ret = resultSet->GetDouble(columnIndex, dVal);
580 EXPECT_EQ(ret, E_OK);
581 EXPECT_EQ(200.5, dVal);
582 ret = resultSet->GetColumnIndex("blobType", columnIndex);
583 EXPECT_EQ(ret, E_OK);
584 ret = resultSet->GetBlob(columnIndex, blob);
585 EXPECT_EQ(ret, E_OK);
586 EXPECT_EQ(3, static_cast<int>(blob.size()));
587 EXPECT_EQ(4, blob[0]);
588 EXPECT_EQ(5, blob[1]);
589 EXPECT_EQ(6, blob[2]);
590
591 ret = resultSet->GoToNextRow();
592 EXPECT_EQ(ret, E_ERROR);
593
594 ret = resultSet->Close();
595 EXPECT_EQ(ret, E_OK);
596 }
597
598 /**
599 * @tc.name: RdbStore_UpdateWithConflictResolution_003
600 * @tc.desc: test RdbStore UpdateWithConflictResolution
601 * @tc.type: FUNC
602 * @tc.require: AR000CU2BO
603 * @tc.author: chenxi
604 */
605 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize.Level1)
606 {
607 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
608
609 int64_t id;
610 ValuesBucket values;
611 int changedRows;
612
613 values.PutInt("id", 1);
614 values.PutString("name", std::string("zhangsan"));
615 values.PutInt("age", 18);
616 values.PutDouble("salary", 100.5);
617 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
618 int ret = store->Insert(id, "test", values);
619 EXPECT_EQ(ret, E_OK);
620 EXPECT_EQ(1, id);
621
622 values.Clear();
623 values.PutInt("id", 2);
624 values.PutString("name", std::string("lisi"));
625 values.PutInt("age", 19);
626 values.PutDouble("salary", 200.5);
627 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
628 ret = store->Insert(id, "test", values);
629 EXPECT_EQ(ret, E_OK);
630 EXPECT_EQ(2, id);
631
632 // update lisi age=19 to wangjing age=20
633 values.Clear();
634 values.PutInt("id", 3);
635 values.PutString("name", std::string("wangjing"));
636 values.PutInt("age", 20);
637 values.PutDouble("salary", 300.5);
638 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
639 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
640 ConflictResolution::ON_CONFLICT_ROLLBACK);
641 EXPECT_EQ(ret, E_OK);
642 EXPECT_EQ(1, changedRows);
643
644 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
645 EXPECT_NE(resultSet, nullptr);
646
647 int columnIndex;
648 int intVal;
649 std::string strVal;
650 double dVal;
651 std::vector<uint8_t> blob;
652
653 ret = resultSet->GoToNextRow();
654 EXPECT_EQ(ret, E_OK);
655 ret = resultSet->GetColumnIndex("id", columnIndex);
656 EXPECT_EQ(ret, E_OK);
657 ret = resultSet->GetInt(columnIndex, intVal);
658 EXPECT_EQ(ret, E_OK);
659 EXPECT_EQ(1, intVal);
660 ret = resultSet->GetColumnIndex("name", columnIndex);
661 EXPECT_EQ(ret, E_OK);
662 ret = resultSet->GetString(columnIndex, strVal);
663 EXPECT_EQ(ret, E_OK);
664 EXPECT_EQ("zhangsan", strVal);
665 ret = resultSet->GetColumnIndex("age", columnIndex);
666 EXPECT_EQ(ret, E_OK);
667 ret = resultSet->GetInt(columnIndex, intVal);
668 EXPECT_EQ(ret, E_OK);
669 EXPECT_EQ(18, intVal);
670 ret = resultSet->GetColumnIndex("salary", columnIndex);
671 EXPECT_EQ(ret, E_OK);
672 ret = resultSet->GetDouble(columnIndex, dVal);
673 EXPECT_EQ(ret, E_OK);
674 EXPECT_EQ(100.5, dVal);
675 ret = resultSet->GetColumnIndex("blobType", columnIndex);
676 EXPECT_EQ(ret, E_OK);
677 ret = resultSet->GetBlob(columnIndex, blob);
678 EXPECT_EQ(ret, E_OK);
679 EXPECT_EQ(3, static_cast<int>(blob.size()));
680 EXPECT_EQ(1, blob[0]);
681 EXPECT_EQ(2, blob[1]);
682 EXPECT_EQ(3, blob[2]);
683
684 ret = resultSet->GoToNextRow();
685 EXPECT_EQ(ret, E_OK);
686 ret = resultSet->GetColumnIndex("id", columnIndex);
687 EXPECT_EQ(ret, E_OK);
688 ret = resultSet->GetInt(columnIndex, intVal);
689 EXPECT_EQ(ret, E_OK);
690 EXPECT_EQ(3, intVal);
691 ret = resultSet->GetColumnIndex("name", columnIndex);
692 EXPECT_EQ(ret, E_OK);
693 ret = resultSet->GetString(columnIndex, strVal);
694 EXPECT_EQ(ret, E_OK);
695 EXPECT_EQ("wangjing", strVal);
696 ret = resultSet->GetColumnIndex("age", columnIndex);
697 EXPECT_EQ(ret, E_OK);
698 ret = resultSet->GetInt(columnIndex, intVal);
699 EXPECT_EQ(ret, E_OK);
700 EXPECT_EQ(20, intVal);
701 ret = resultSet->GetColumnIndex("salary", columnIndex);
702 EXPECT_EQ(ret, E_OK);
703 ret = resultSet->GetDouble(columnIndex, dVal);
704 EXPECT_EQ(ret, E_OK);
705 EXPECT_EQ(300.5, dVal);
706 ret = resultSet->GetColumnIndex("blobType", columnIndex);
707 EXPECT_EQ(ret, E_OK);
708 ret = resultSet->GetBlob(columnIndex, blob);
709 EXPECT_EQ(ret, E_OK);
710 EXPECT_EQ(3, static_cast<int>(blob.size()));
711 EXPECT_EQ(7, blob[0]);
712 EXPECT_EQ(8, blob[1]);
713 EXPECT_EQ(9, blob[2]);
714
715 ret = resultSet->GoToNextRow();
716 EXPECT_EQ(ret, E_ERROR);
717
718 ret = resultSet->Close();
719 EXPECT_EQ(ret, E_OK);
720 }
721
722 /**
723 * @tc.name: RdbStore_UpdateWithConflictResolution_004
724 * @tc.desc: test RdbStore UpdateWithConflictResolution
725 * @tc.type: FUNC
726 * @tc.require: AR000CU2BO
727 * @tc.author: chenxi
728 */
729 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize.Level1)
730 {
731 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
732
733 int64_t id;
734 ValuesBucket values;
735 int changedRows;
736
737 values.PutInt("id", 1);
738 values.PutString("name", std::string("zhangsan"));
739 values.PutInt("age", 18);
740 values.PutDouble("salary", 100.5);
741 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
742 int ret = store->Insert(id, "test", values);
743 EXPECT_EQ(ret, E_OK);
744 EXPECT_EQ(1, id);
745
746 values.Clear();
747 values.PutInt("id", 2);
748 values.PutString("name", std::string("lisi"));
749 values.PutInt("age", 19);
750 values.PutDouble("salary", 200.5);
751 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
752 ret = store->Insert(id, "test", values);
753 EXPECT_EQ(ret, E_OK);
754 EXPECT_EQ(2, id);
755
756 // update lisi age=19 to zhangsan age=20
757 values.Clear();
758 values.PutInt("id", 3);
759 values.PutString("name", std::string("zhangsan"));
760 values.PutInt("age", 20);
761 values.PutDouble("salary", 300.5);
762 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
763 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
764 ConflictResolution::ON_CONFLICT_ROLLBACK);
765 EXPECT_EQ(ret, RdbStoreUpdateTest::E_SQLITE_CONSTRAINT);
766
767 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
768 EXPECT_NE(resultSet, nullptr);
769
770 int columnIndex;
771 int intVal;
772 std::string strVal;
773 double dVal;
774 std::vector<uint8_t> blob;
775
776 ret = resultSet->GoToNextRow();
777 EXPECT_EQ(ret, E_OK);
778 ret = resultSet->GetColumnIndex("id", columnIndex);
779 EXPECT_EQ(ret, E_OK);
780 ret = resultSet->GetInt(columnIndex, intVal);
781 EXPECT_EQ(ret, E_OK);
782 EXPECT_EQ(1, intVal);
783 ret = resultSet->GetColumnIndex("name", columnIndex);
784 EXPECT_EQ(ret, E_OK);
785 ret = resultSet->GetString(columnIndex, strVal);
786 EXPECT_EQ(ret, E_OK);
787 EXPECT_EQ("zhangsan", strVal);
788 ret = resultSet->GetColumnIndex("age", columnIndex);
789 EXPECT_EQ(ret, E_OK);
790 ret = resultSet->GetInt(columnIndex, intVal);
791 EXPECT_EQ(ret, E_OK);
792 EXPECT_EQ(18, intVal);
793 ret = resultSet->GetColumnIndex("salary", columnIndex);
794 EXPECT_EQ(ret, E_OK);
795 ret = resultSet->GetDouble(columnIndex, dVal);
796 EXPECT_EQ(ret, E_OK);
797 EXPECT_EQ(100.5, dVal);
798 ret = resultSet->GetColumnIndex("blobType", columnIndex);
799 EXPECT_EQ(ret, E_OK);
800 ret = resultSet->GetBlob(columnIndex, blob);
801 EXPECT_EQ(ret, E_OK);
802 EXPECT_EQ(3, static_cast<int>(blob.size()));
803 EXPECT_EQ(1, blob[0]);
804 EXPECT_EQ(2, blob[1]);
805 EXPECT_EQ(3, blob[2]);
806
807 ret = resultSet->GoToNextRow();
808 EXPECT_EQ(ret, E_OK);
809 ret = resultSet->GetColumnIndex("id", columnIndex);
810 EXPECT_EQ(ret, E_OK);
811 ret = resultSet->GetInt(columnIndex, intVal);
812 EXPECT_EQ(ret, E_OK);
813 EXPECT_EQ(2, intVal);
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("lisi", strVal);
819 ret = resultSet->GetColumnIndex("age", columnIndex);
820 EXPECT_EQ(ret, E_OK);
821 ret = resultSet->GetInt(columnIndex, intVal);
822 EXPECT_EQ(ret, E_OK);
823 EXPECT_EQ(19, intVal);
824 ret = resultSet->GetColumnIndex("salary", columnIndex);
825 EXPECT_EQ(ret, E_OK);
826 ret = resultSet->GetDouble(columnIndex, dVal);
827 EXPECT_EQ(ret, E_OK);
828 EXPECT_EQ(200.5, dVal);
829 ret = resultSet->GetColumnIndex("blobType", columnIndex);
830 EXPECT_EQ(ret, E_OK);
831 ret = resultSet->GetBlob(columnIndex, blob);
832 EXPECT_EQ(ret, E_OK);
833 EXPECT_EQ(3, static_cast<int>(blob.size()));
834 EXPECT_EQ(4, blob[0]);
835 EXPECT_EQ(5, blob[1]);
836 EXPECT_EQ(6, blob[2]);
837
838 ret = resultSet->GoToNextRow();
839 EXPECT_EQ(ret, E_ERROR);
840
841 ret = resultSet->Close();
842 EXPECT_EQ(ret, E_OK);
843 }
844
845 /**
846 * @tc.name: RdbStore_UpdateWithConflictResolution_005
847 * @tc.desc: test RdbStore UpdateWithConflictResolution
848 * @tc.type: FUNC
849 * @tc.require: AR000CU2BO
850 * @tc.author: chenxi
851 */
852 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize.Level1)
853 {
854 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
855
856 int64_t id;
857 ValuesBucket values;
858 int changedRows;
859
860 values.PutInt("id", 1);
861 values.PutString("name", std::string("zhangsan"));
862 values.PutInt("age", 18);
863 values.PutDouble("salary", 100.5);
864 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
865 int ret = store->Insert(id, "test", values);
866 EXPECT_EQ(ret, E_OK);
867 EXPECT_EQ(1, id);
868
869 values.Clear();
870 values.PutInt("id", 2);
871 values.PutString("name", std::string("lisi"));
872 values.PutInt("age", 19);
873 values.PutDouble("salary", 200.5);
874 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
875 ret = store->Insert(id, "test", values);
876 EXPECT_EQ(ret, E_OK);
877 EXPECT_EQ(2, id);
878
879 // update lisi age=19 to wangjing age=20
880 values.Clear();
881 values.PutInt("id", 3);
882 values.PutString("name", std::string("wangjing"));
883 values.PutInt("age", 20);
884 values.PutDouble("salary", 300.5);
885 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
886 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
887 ConflictResolution::ON_CONFLICT_REPLACE);
888 EXPECT_EQ(ret, E_OK);
889 EXPECT_EQ(1, changedRows);
890
891 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
892 EXPECT_NE(resultSet, nullptr);
893
894 int columnIndex;
895 int intVal;
896 std::string strVal;
897 double dVal;
898 std::vector<uint8_t> blob;
899
900 ret = resultSet->GoToNextRow();
901 EXPECT_EQ(ret, E_OK);
902 ret = resultSet->GetColumnIndex("id", columnIndex);
903 EXPECT_EQ(ret, E_OK);
904 ret = resultSet->GetInt(columnIndex, intVal);
905 EXPECT_EQ(ret, E_OK);
906 EXPECT_EQ(1, intVal);
907 ret = resultSet->GetColumnIndex("name", columnIndex);
908 EXPECT_EQ(ret, E_OK);
909 ret = resultSet->GetString(columnIndex, strVal);
910 EXPECT_EQ(ret, E_OK);
911 EXPECT_EQ("zhangsan", strVal);
912 ret = resultSet->GetColumnIndex("age", columnIndex);
913 EXPECT_EQ(ret, E_OK);
914 ret = resultSet->GetInt(columnIndex, intVal);
915 EXPECT_EQ(ret, E_OK);
916 EXPECT_EQ(18, intVal);
917 ret = resultSet->GetColumnIndex("salary", columnIndex);
918 EXPECT_EQ(ret, E_OK);
919 ret = resultSet->GetDouble(columnIndex, dVal);
920 EXPECT_EQ(ret, E_OK);
921 EXPECT_EQ(100.5, dVal);
922 ret = resultSet->GetColumnIndex("blobType", columnIndex);
923 EXPECT_EQ(ret, E_OK);
924 ret = resultSet->GetBlob(columnIndex, blob);
925 EXPECT_EQ(ret, E_OK);
926 EXPECT_EQ(3, static_cast<int>(blob.size()));
927 EXPECT_EQ(1, blob[0]);
928 EXPECT_EQ(2, blob[1]);
929 EXPECT_EQ(3, blob[2]);
930
931 ret = resultSet->GoToNextRow();
932 EXPECT_EQ(ret, E_OK);
933 ret = resultSet->GetColumnIndex("id", columnIndex);
934 EXPECT_EQ(ret, E_OK);
935 ret = resultSet->GetInt(columnIndex, intVal);
936 EXPECT_EQ(ret, E_OK);
937 EXPECT_EQ(3, intVal);
938 ret = resultSet->GetColumnIndex("name", columnIndex);
939 EXPECT_EQ(ret, E_OK);
940 ret = resultSet->GetString(columnIndex, strVal);
941 EXPECT_EQ(ret, E_OK);
942 EXPECT_EQ("wangjing", strVal);
943 ret = resultSet->GetColumnIndex("age", columnIndex);
944 EXPECT_EQ(ret, E_OK);
945 ret = resultSet->GetInt(columnIndex, intVal);
946 EXPECT_EQ(ret, E_OK);
947 EXPECT_EQ(20, intVal);
948 ret = resultSet->GetColumnIndex("salary", columnIndex);
949 EXPECT_EQ(ret, E_OK);
950 ret = resultSet->GetDouble(columnIndex, dVal);
951 EXPECT_EQ(ret, E_OK);
952 EXPECT_EQ(300.5, dVal);
953 ret = resultSet->GetColumnIndex("blobType", columnIndex);
954 EXPECT_EQ(ret, E_OK);
955 ret = resultSet->GetBlob(columnIndex, blob);
956 EXPECT_EQ(ret, E_OK);
957 EXPECT_EQ(3, static_cast<int>(blob.size()));
958 EXPECT_EQ(7, blob[0]);
959 EXPECT_EQ(8, blob[1]);
960 EXPECT_EQ(9, blob[2]);
961
962 ret = resultSet->GoToNextRow();
963 EXPECT_EQ(ret, E_ERROR);
964
965 ret = resultSet->Close();
966 EXPECT_EQ(ret, E_OK);
967 }
968
969 /**
970 * @tc.name: RdbStore_UpdateWithConflictResolution_006
971 * @tc.desc: test RdbStore UpdateWithConflictResolution
972 * @tc.type: FUNC
973 * @tc.require: AR000CU2BO
974 * @tc.author: chenxi
975 */
976 HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize.Level1)
977 {
978 std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
979
980 int64_t id;
981 ValuesBucket values;
982 int changedRows;
983
984 values.PutInt("id", 1);
985 values.PutString("name", std::string("zhangsan"));
986 values.PutInt("age", 18);
987 values.PutDouble("salary", 100.5);
988 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
989 int ret = store->Insert(id, "test", values);
990 EXPECT_EQ(ret, E_OK);
991 EXPECT_EQ(1, id);
992
993 values.Clear();
994 values.PutInt("id", 2);
995 values.PutString("name", std::string("lisi"));
996 values.PutInt("age", 19);
997 values.PutDouble("salary", 200.5);
998 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
999 ret = store->Insert(id, "test", values);
1000 EXPECT_EQ(ret, E_OK);
1001 EXPECT_EQ(2, id);
1002
1003 // update lisi age=19 to zhangsan age=20
1004 values.Clear();
1005 values.PutString("name", std::string("zhangsan"));
1006 values.PutInt("age", 20);
1007 values.PutDouble("salary", 300.5);
1008 ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
1009 ConflictResolution::ON_CONFLICT_REPLACE);
1010 EXPECT_EQ(ret, E_OK);
1011 EXPECT_EQ(changedRows, 1);
1012
1013 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
1014 EXPECT_NE(resultSet, nullptr);
1015
1016 int columnIndex;
1017 int intVal;
1018 std::string strVal;
1019 double dVal;
1020 std::vector<uint8_t> blob;
1021
1022 ret = resultSet->GoToNextRow();
1023 EXPECT_EQ(ret, E_OK);
1024 ret = resultSet->GetColumnIndex("id", columnIndex);
1025 EXPECT_EQ(ret, E_OK);
1026 ret = resultSet->GetInt(columnIndex, intVal);
1027 EXPECT_EQ(ret, E_OK);
1028 EXPECT_EQ(2, intVal);
1029 ret = resultSet->GetColumnIndex("name", columnIndex);
1030 EXPECT_EQ(ret, E_OK);
1031 ret = resultSet->GetString(columnIndex, strVal);
1032 EXPECT_EQ(ret, E_OK);
1033 EXPECT_EQ("zhangsan", strVal);
1034 ret = resultSet->GetColumnIndex("age", columnIndex);
1035 EXPECT_EQ(ret, E_OK);
1036 ret = resultSet->GetInt(columnIndex, intVal);
1037 EXPECT_EQ(ret, E_OK);
1038 EXPECT_EQ(20, intVal);
1039 ret = resultSet->GetColumnIndex("salary", columnIndex);
1040 EXPECT_EQ(ret, E_OK);
1041 ret = resultSet->GetDouble(columnIndex, dVal);
1042 EXPECT_EQ(ret, E_OK);
1043 EXPECT_EQ(300.5, dVal);
1044 ret = resultSet->GetColumnIndex("blobType", columnIndex);
1045 EXPECT_EQ(ret, E_OK);
1046 ret = resultSet->GetBlob(columnIndex, blob);
1047 EXPECT_EQ(ret, E_OK);
1048 EXPECT_EQ(3, static_cast<int>(blob.size()));
1049 EXPECT_EQ(4, blob[0]);
1050 EXPECT_EQ(5, blob[1]);
1051 EXPECT_EQ(6, blob[2]);
1052
1053 ret = resultSet->GoToNextRow();
1054 EXPECT_EQ(ret, E_ERROR);
1055
1056 ret = resultSet->Close();
1057 EXPECT_EQ(ret, E_OK);
1058 }
1059