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