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