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
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::shared_ptr<ResultSet> &resultSet);
37 void CheckSalary(std::shared_ptr<ResultSet> &resultSet);
38 void CheckBlob(std::shared_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 &store) override;
54 int OnUpgrade(RdbStore &store, 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 */
101 HWTEST_F(RdbStoreInsertTest, RdbStore_Insert_001, TestSize.Level1)
102 {
103 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
104
105 int64_t id;
106 ValuesBucket values;
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", 18);
121 values.PutDouble("salary", 100.5);
122 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
123 ret = store->Insert(id, "test", values);
124 EXPECT_EQ(ret, E_OK);
125 EXPECT_EQ(2, id);
126
127 values.Clear();
128 values.PutInt("id", 3);
129 values.PutString("name", std::string("lisi"));
130 values.PutInt("age", 20L);
131 values.PutDouble("salary", 100.5f);
132 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
133 ret = store->Insert(id, "test", values);
134 EXPECT_EQ(ret, E_OK);
135 EXPECT_EQ(3, id);
136
137 RdbStoreInsertTest::CheckResultSet(store);
138 }
139
CheckResultSet(std::shared_ptr<RdbStore> & store)140 void RdbStoreInsertTest::CheckResultSet(std::shared_ptr<RdbStore> &store)
141 {
142 std::shared_ptr<ResultSet> resultSet =
143 store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
144 EXPECT_NE(resultSet, nullptr);
145
146 int columnIndex;
147 int intVal;
148 std::string strVal;
149 ColumnType columnType;
150 int position;
151 int ret = resultSet->GetRowIndex(position);
152 EXPECT_EQ(ret, E_OK);
153 EXPECT_EQ(position, -1);
154
155 ret = resultSet->GetColumnType(0, columnType);
156 EXPECT_EQ(ret, E_INVALID_STATEMENT);
157
158 ret = resultSet->GoToFirstRow();
159 EXPECT_EQ(ret, E_OK);
160
161 ret = resultSet->GetColumnIndex("id", columnIndex);
162 EXPECT_EQ(ret, E_OK);
163 EXPECT_EQ(columnIndex, 0);
164 ret = resultSet->GetColumnType(columnIndex, columnType);
165 EXPECT_EQ(ret, E_OK);
166 EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER);
167 ret = resultSet->GetInt(columnIndex, intVal);
168 EXPECT_EQ(ret, E_OK);
169 EXPECT_EQ(1, intVal);
170
171 ret = resultSet->GetColumnIndex("name", columnIndex);
172 EXPECT_EQ(ret, E_OK);
173 ret = resultSet->GetColumnType(columnIndex, columnType);
174 EXPECT_EQ(ret, E_OK);
175 EXPECT_EQ(columnType, ColumnType::TYPE_STRING);
176 ret = resultSet->GetString(columnIndex, strVal);
177 EXPECT_EQ(ret, E_OK);
178 EXPECT_EQ("zhangsan", strVal);
179
180 RdbStoreInsertTest::CheckAge(resultSet);
181 RdbStoreInsertTest::CheckSalary(resultSet);
182 RdbStoreInsertTest::CheckBlob(resultSet);
183
184 ret = resultSet->GoToNextRow();
185 EXPECT_EQ(ret, E_ERROR);
186
187 ret = resultSet->GetColumnType(columnIndex, columnType);
188 EXPECT_EQ(ret, E_INVALID_STATEMENT);
189
190 ret = resultSet->Close();
191 EXPECT_EQ(ret, E_OK);
192 }
193
CheckAge(std::shared_ptr<ResultSet> & resultSet)194 void RdbStoreInsertTest::CheckAge(std::shared_ptr<ResultSet> &resultSet)
195 {
196 int columnIndex;
197 int intVal;
198 ColumnType columnType;
199 int ret = resultSet->GetColumnIndex("age", columnIndex);
200 EXPECT_EQ(ret, E_OK);
201 ret = resultSet->GetColumnType(columnIndex, columnType);
202 EXPECT_EQ(ret, E_OK);
203 EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER);
204 ret = resultSet->GetInt(columnIndex, intVal);
205 EXPECT_EQ(ret, E_OK);
206 EXPECT_EQ(18, intVal);
207 }
208
CheckSalary(std::shared_ptr<ResultSet> & resultSet)209 void RdbStoreInsertTest::CheckSalary(std::shared_ptr<ResultSet> &resultSet)
210 {
211 int columnIndex;
212 double dVal;
213 ColumnType columnType;
214 int ret = resultSet->GetColumnIndex("salary", columnIndex);
215 EXPECT_EQ(ret, E_OK);
216 ret = resultSet->GetColumnType(columnIndex, columnType);
217 EXPECT_EQ(ret, E_OK);
218 EXPECT_EQ(columnType, ColumnType::TYPE_FLOAT);
219 ret = resultSet->GetDouble(columnIndex, dVal);
220 EXPECT_EQ(ret, E_OK);
221 EXPECT_EQ(100.5, dVal);
222 }
223
CheckBlob(std::shared_ptr<ResultSet> & resultSet)224 void RdbStoreInsertTest::CheckBlob(std::shared_ptr<ResultSet> &resultSet)
225 {
226 int columnIndex;
227 std::vector<uint8_t> blob;
228 ColumnType columnType;
229 int ret = resultSet->GetColumnIndex("blobType", columnIndex);
230 EXPECT_EQ(ret, E_OK);
231 ret = resultSet->GetColumnType(columnIndex, columnType);
232 EXPECT_EQ(ret, E_OK);
233 EXPECT_EQ(columnType, ColumnType::TYPE_BLOB);
234 ret = resultSet->GetBlob(columnIndex, blob);
235 EXPECT_EQ(ret, E_OK);
236 EXPECT_EQ(3, static_cast<int>(blob.size()));
237 EXPECT_EQ(1, blob[0]);
238 EXPECT_EQ(2, blob[1]);
239 EXPECT_EQ(3, blob[2]);
240 }
241
242 /**
243 * @tc.name: RdbStore_Insert_002
244 * @tc.desc: test RdbStore insert
245 * @tc.type: FUNC
246 */
247 HWTEST_F(RdbStoreInsertTest, RdbStore_Insert_002, TestSize.Level1)
248 {
249 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
250
251 int64_t id;
252 ValuesBucket values;
253 values.PutInt("id", 1);
254 values.PutString("name", std::string("zhangsan"));
255 values.PutInt("age", 18);
256 values.PutDouble("salary", 100.5);
257 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
258 int ret = store->Insert(id, "", values); // empty table name
259 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
260
261 ret = store->Insert(id, "wrongTable", values); // no such table
262 EXPECT_EQ(ret, RdbStoreInsertTest::E_SQLITE_ERROR);
263 }
264
265 /**
266 * @tc.name: RdbStore_Insert_003
267 * @tc.desc: test RdbStore insert
268 * @tc.type: FUNC
269 */
270 HWTEST_F(RdbStoreInsertTest, RdbStore_Insert_003, TestSize.Level1)
271 {
272 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
273
274 int64_t id;
275 ValuesBucket emptyBucket;
276 int ret = store->Insert(id, "test", emptyBucket);
277 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
278
279 ValuesBucket values;
280 values.PutInt("id", 1);
281 values.PutString("name", std::string("zhangsan"));
282 values.PutInt("age", 18);
283 values.PutDouble("wrongColumn", 100.5); // no such column
284 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
285 ret = store->Insert(id, "test", values);
286 EXPECT_EQ(ret, RdbStoreInsertTest::E_SQLITE_ERROR);
287 }
288
289 /**
290 * @tc.name: RdbStore_Replace_001
291 * @tc.desc: test RdbStore replace
292 * @tc.type: FUNC
293 */
294 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_001, TestSize.Level1)
295 {
296 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
297
298 int64_t id;
299 ValuesBucket values;
300
301 int ret = store->Replace(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
302 EXPECT_EQ(ret, E_OK);
303 EXPECT_EQ(1, id);
304
305 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
306 EXPECT_NE(resultSet, nullptr);
307
308 ret = resultSet->GoToNextRow();
309 EXPECT_EQ(ret, E_OK);
310
311 int columnIndex;
312 int intVal;
313 std::string strVal;
314
315 ret = resultSet->GetColumnIndex("id", columnIndex);
316 EXPECT_EQ(ret, E_OK);
317 ret = resultSet->GetInt(columnIndex, intVal);
318 EXPECT_EQ(ret, E_OK);
319 EXPECT_EQ(1, intVal);
320
321 ret = resultSet->GetColumnIndex("name", columnIndex);
322 EXPECT_EQ(ret, E_OK);
323 ret = resultSet->GetString(columnIndex, strVal);
324 EXPECT_EQ(ret, E_OK);
325 EXPECT_EQ("zhangsan", strVal);
326
327 ret = resultSet->GetColumnIndex("age", columnIndex);
328 EXPECT_EQ(ret, E_OK);
329 ret = resultSet->GetInt(columnIndex, intVal);
330 EXPECT_EQ(ret, E_OK);
331 EXPECT_EQ(18, intVal);
332
333 ret = resultSet->GoToNextRow();
334 EXPECT_EQ(ret, E_ERROR);
335
336 ret = resultSet->Close();
337 EXPECT_EQ(ret, E_OK);
338 }
339
340 /**
341 * @tc.name: RdbStore_Replace_002
342 * @tc.desc: test RdbStore replace
343 * @tc.type: FUNC
344 */
345 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_002, TestSize.Level1)
346 {
347 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
348
349 int64_t id;
350 ValuesBucket values;
351
352 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
353 EXPECT_EQ(ret, E_OK);
354 EXPECT_EQ(1, id);
355
356 values.Clear();
357 values.PutInt("id", 1);
358 values.PutString("name", std::string("zhangsan"));
359 values.PutInt("age", 18);
360 values.PutDouble("salary", 200.5);
361 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
362 ret = store->Replace(id, "test", values);
363 EXPECT_EQ(ret, E_OK);
364 EXPECT_EQ(1, id);
365
366 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
367 EXPECT_NE(resultSet, nullptr);
368
369 ret = resultSet->GoToNextRow();
370 EXPECT_EQ(ret, E_OK);
371
372 int columnIndex;
373 int intVal;
374 std::string strVal;
375
376 ret = resultSet->GetColumnIndex("id", columnIndex);
377 EXPECT_EQ(ret, E_OK);
378 ret = resultSet->GetInt(columnIndex, intVal);
379 EXPECT_EQ(ret, E_OK);
380 EXPECT_EQ(1, intVal);
381
382 ret = resultSet->GetColumnIndex("name", columnIndex);
383 EXPECT_EQ(ret, E_OK);
384 ret = resultSet->GetString(columnIndex, strVal);
385 EXPECT_EQ(ret, E_OK);
386 EXPECT_EQ("zhangsan", strVal);
387
388 ret = resultSet->GetColumnIndex("age", columnIndex);
389 EXPECT_EQ(ret, E_OK);
390 ret = resultSet->GetInt(columnIndex, intVal);
391 EXPECT_EQ(ret, E_OK);
392 EXPECT_EQ(18, intVal);
393
394 ret = resultSet->GoToNextRow();
395 EXPECT_EQ(ret, E_ERROR);
396
397 ret = resultSet->Close();
398 EXPECT_EQ(ret, E_OK);
399 }
400
401 /**
402 * @tc.name: RdbStore_Replace_003
403 * @tc.desc: test RdbStore Replace
404 * @tc.type: FUNC
405 */
406 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_003, TestSize.Level1)
407 {
408 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
409
410 int64_t id;
411 ValuesBucket values;
412 values.PutInt("id", 1);
413 values.PutString("name", std::string("zhangsan"));
414 values.PutInt("age", 18);
415 values.PutDouble("salary", 100.5);
416 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
417 int ret = store->Replace(id, "", values); // empty table name
418 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
419
420 ret = store->Replace(id, "wrongTable", values); // no such table
421 EXPECT_EQ(ret, RdbStoreInsertTest::E_SQLITE_ERROR);
422 }
423
424 /**
425 * @tc.name: RdbStore_Replace_004
426 * @tc.desc: test RdbStore Replace
427 * @tc.type: FUNC
428 */
429 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_004, TestSize.Level1)
430 {
431 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
432
433 int64_t id;
434 ValuesBucket emptyBucket;
435 int ret = store->Replace(id, "test", emptyBucket);
436 EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
437
438 ValuesBucket values;
439 values.PutInt("id", 1);
440 values.PutString("name", std::string("zhangsan"));
441 values.PutInt("age", 18);
442 values.PutDouble("wrongColumn", 100.5); // no such column
443 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
444 ret = store->Replace(id, "test", values);
445 EXPECT_EQ(ret, RdbStoreInsertTest::E_SQLITE_ERROR);
446 }
447
448 /**
449 * @tc.name: RdbStore_Replace_005
450 * @tc.desc: test RdbStore replace, getcolumn dVal and blob
451 * @tc.type: FUNC
452 */
453 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_005, TestSize.Level1)
454 {
455 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
456
457 int64_t id;
458
459 int ret = store->Replace(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
460 EXPECT_EQ(ret, E_OK);
461 EXPECT_EQ(1, id);
462
463 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
464 EXPECT_NE(resultSet, nullptr);
465
466 ret = resultSet->GoToNextRow();
467 EXPECT_EQ(ret, E_OK);
468
469 int columnIndex;
470 double dVal;
471 std::vector<uint8_t> blob;
472
473 ret = resultSet->GetColumnIndex("salary", columnIndex);
474 EXPECT_EQ(ret, E_OK);
475 ret = resultSet->GetDouble(columnIndex, dVal);
476 EXPECT_EQ(ret, E_OK);
477 EXPECT_EQ(100.5, dVal);
478
479 ret = resultSet->GetColumnIndex("blobType", columnIndex);
480 EXPECT_EQ(ret, E_OK);
481 ret = resultSet->GetBlob(columnIndex, blob);
482 EXPECT_EQ(ret, E_OK);
483 EXPECT_EQ(3, static_cast<int>(blob.size()));
484 EXPECT_EQ(1, blob[0]);
485 EXPECT_EQ(2, blob[1]);
486 EXPECT_EQ(3, blob[2]);
487
488 ret = resultSet->GoToNextRow();
489 EXPECT_EQ(ret, E_ERROR);
490
491 ret = resultSet->Close();
492 EXPECT_EQ(ret, E_OK);
493 }
494
495 /**
496 * @tc.name: RdbStore_Replace_006
497 * @tc.desc: test RdbStore replace
498 * @tc.type: FUNC
499 */
500 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_006, TestSize.Level1)
501 {
502 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
503
504 int64_t id;
505 ValuesBucket values;
506
507 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
508 EXPECT_EQ(ret, E_OK);
509 EXPECT_EQ(1, id);
510
511 values.Clear();
512 values.PutInt("id", 1);
513 values.PutString("name", std::string("zhangsan"));
514 values.PutInt("age", 18);
515 values.PutDouble("salary", 200.5);
516 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
517 ret = store->Replace(id, "test", values);
518 EXPECT_EQ(ret, E_OK);
519 EXPECT_EQ(1, id);
520
521 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
522 EXPECT_NE(resultSet, nullptr);
523
524 ret = resultSet->GoToNextRow();
525 EXPECT_EQ(ret, E_OK);
526
527 int columnIndex;
528 double dVal;
529 std::vector<uint8_t> blob;
530
531 ret = resultSet->GetColumnIndex("salary", columnIndex);
532 EXPECT_EQ(ret, E_OK);
533 ret = resultSet->GetDouble(columnIndex, dVal);
534 EXPECT_EQ(ret, E_OK);
535 EXPECT_EQ(200.5, dVal);
536
537 ret = resultSet->GetColumnIndex("blobType", columnIndex);
538 EXPECT_EQ(ret, E_OK);
539 ret = resultSet->GetBlob(columnIndex, blob);
540 EXPECT_EQ(ret, E_OK);
541 EXPECT_EQ(3, static_cast<int>(blob.size()));
542 EXPECT_EQ(1, blob[0]);
543 EXPECT_EQ(2, blob[1]);
544 EXPECT_EQ(3, blob[2]);
545
546 ret = resultSet->GoToNextRow();
547 EXPECT_EQ(ret, E_ERROR);
548
549 ret = resultSet->Close();
550 EXPECT_EQ(ret, E_OK);
551 }
552
553 /**
554 * @tc.name: RdbStore_InsertWithConflictResolution_001_002
555 * @tc.desc: test RdbStore InsertWithConflictResolution
556 * @tc.type: FUNC
557 */
558 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_001_002, TestSize.Level1)
559 {
560 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
561
562 int64_t id;
563 ValuesBucket values;
564
565 values.PutInt("id", 1);
566 values.PutString("name", std::string("zhangsan"));
567 values.PutInt("age", 18);
568 values.PutDouble("salary", 100.5);
569 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
570
571 // default is ConflictResolution::ON_CONFLICT_NONE
572 int ret = store->InsertWithConflictResolution(id, "test", values);
573 EXPECT_EQ(ret, E_OK);
574 EXPECT_EQ(1, id);
575
576 values.Clear();
577 values.PutInt("id", 1);
578 values.PutString("name", std::string("zhangsan"));
579 values.PutInt("age", 18);
580 values.PutDouble("salary", 200.5);
581 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
582 ret = store->InsertWithConflictResolution(id, "test", values);
583 EXPECT_EQ(ret, RdbStoreInsertTest::E_SQLITE_CONSTRAINT);
584 }
585
586 /**
587 * @tc.name: RdbStore_InsertWithConflictResolution_003_004
588 * @tc.desc: test RdbStore InsertWithConflictResolution
589 * @tc.type: FUNC
590 */
591 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_003_004, TestSize.Level1)
592 {
593 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
594
595 int64_t id;
596 ValuesBucket values;
597
598 values.PutInt("id", 1);
599 values.PutString("name", std::string("zhangsan"));
600 values.PutInt("age", 18);
601 values.PutDouble("salary", 100.5);
602 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
603 int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_ROLLBACK);
604 EXPECT_EQ(ret, E_OK);
605 EXPECT_EQ(1, id);
606
607 values.Clear();
608 values.PutInt("id", 1);
609 values.PutString("name", std::string("zhangsan"));
610 values.PutInt("age", 18);
611 values.PutDouble("salary", 200.5);
612 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
613 ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_ROLLBACK);
614 EXPECT_EQ(ret, RdbStoreInsertTest::E_SQLITE_CONSTRAINT);
615 }
616
617 /**
618 * @tc.name: RdbStore_InsertWithConflictResolution_005
619 * @tc.desc: test RdbStore InsertWithConflictResolution
620 * @tc.type: FUNC
621 */
622 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_005, TestSize.Level1)
623 {
624 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
625
626 int64_t id;
627 ValuesBucket values;
628
629 values.PutInt("id", 1);
630 values.PutString("name", std::string("zhangsan"));
631 values.PutInt("age", 18);
632 values.PutDouble("salary", 100.5);
633 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
634 int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_IGNORE);
635 EXPECT_EQ(ret, E_OK);
636 EXPECT_EQ(1, id);
637
638 values.Clear();
639 values.PutInt("id", 1);
640 values.PutString("name", std::string("zhangsan"));
641 values.PutInt("age", 18);
642 values.PutDouble("salary", 200.5);
643 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
644 ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_IGNORE);
645 EXPECT_EQ(ret, E_OK);
646 EXPECT_EQ(id, -1);
647 }
648
649 /**
650 * @tc.name: RdbStore_InsertWithConflictResolution_006
651 * @tc.desc: test RdbStore InsertWithConflictResolution
652 * @tc.type: FUNC
653 */
654 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_006, TestSize.Level1)
655 {
656 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
657
658 int64_t id;
659 ValuesBucket values;
660
661 int ret = store->InsertWithConflictResolution(
662 id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]), ConflictResolution::ON_CONFLICT_REPLACE);
663 EXPECT_EQ(ret, E_OK);
664 EXPECT_EQ(1, id);
665
666 values.Clear();
667 values.PutInt("id", 1);
668 values.PutString("name", std::string("zhangsan"));
669 values.PutInt("age", 18);
670 values.PutDouble("salary", 200.5);
671 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
672 ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_REPLACE);
673 EXPECT_EQ(ret, E_OK);
674 EXPECT_EQ(id, 1);
675
676 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
677 EXPECT_NE(resultSet, nullptr);
678
679 ret = resultSet->GoToNextRow();
680 EXPECT_EQ(ret, E_OK);
681
682 int columnIndex;
683 int intVal;
684 std::string strVal;
685
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(1, intVal);
691
692 ret = resultSet->GetColumnIndex("name", columnIndex);
693 EXPECT_EQ(ret, E_OK);
694 ret = resultSet->GetString(columnIndex, strVal);
695 EXPECT_EQ(ret, E_OK);
696 EXPECT_EQ("zhangsan", strVal);
697
698 ret = resultSet->GetColumnIndex("age", columnIndex);
699 EXPECT_EQ(ret, E_OK);
700 ret = resultSet->GetInt(columnIndex, intVal);
701 EXPECT_EQ(ret, E_OK);
702 EXPECT_EQ(18, intVal);
703
704 ret = resultSet->GoToNextRow();
705 EXPECT_EQ(ret, E_ERROR);
706
707 ret = resultSet->Close();
708 EXPECT_EQ(ret, E_OK);
709 }
710
711 /**
712 * @tc.name: RdbStore_InsertWithConflictResolution_007
713 * @tc.desc: test RdbStore InsertWithConflictResolution
714 * @tc.type: FUNC
715 */
716 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_007, TestSize.Level1)
717 {
718 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
719
720 int64_t id;
721 ValuesBucket values;
722
723 int ret = store->InsertWithConflictResolution(
724 id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]), ConflictResolution::ON_CONFLICT_REPLACE);
725 EXPECT_EQ(ret, E_OK);
726 EXPECT_EQ(1, id);
727
728 values.Clear();
729 values.PutInt("id", 1);
730 values.PutString("name", std::string("zhangsan"));
731 values.PutInt("age", 18);
732 values.PutDouble("salary", 200.5);
733 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
734 ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_REPLACE);
735 EXPECT_EQ(ret, E_OK);
736 EXPECT_EQ(id, 1);
737
738 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
739 EXPECT_NE(resultSet, nullptr);
740
741 ret = resultSet->GoToNextRow();
742 EXPECT_EQ(ret, E_OK);
743
744 int columnIndex;
745 double dVal;
746 std::vector<uint8_t> blob;
747
748 ret = resultSet->GetColumnIndex("salary", columnIndex);
749 EXPECT_EQ(ret, E_OK);
750 ret = resultSet->GetDouble(columnIndex, dVal);
751 EXPECT_EQ(ret, E_OK);
752 EXPECT_EQ(200.5, dVal);
753
754 ret = resultSet->GetColumnIndex("blobType", columnIndex);
755 EXPECT_EQ(ret, E_OK);
756 ret = resultSet->GetBlob(columnIndex, blob);
757 EXPECT_EQ(ret, E_OK);
758 EXPECT_EQ(3, static_cast<int>(blob.size()));
759 EXPECT_EQ(4, blob[0]);
760 EXPECT_EQ(5, blob[1]);
761 EXPECT_EQ(6, blob[2]);
762
763 ret = resultSet->GoToNextRow();
764 EXPECT_EQ(ret, E_ERROR);
765
766 ret = resultSet->Close();
767 EXPECT_EQ(ret, E_OK);
768 }
769
770 /**
771 * @tc.name: RdbStore_InsertWithConflictResolution_008
772 * @tc.desc: Abnormal testCase of InsertWithConflictResolution, if conflictResolution is invalid
773 * @tc.type: FUNC
774 */
775 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_008, TestSize.Level1)
776 {
777 std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
778
779 int64_t id;
780 ValuesBucket values;
781
782 values.PutInt("id", 1);
783 values.PutInt("age", 18);
784 int ret = store->InsertWithConflictResolution(id, "test", values, static_cast<ConflictResolution>(6));
785 EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
786 EXPECT_EQ(0, id);
787
788 values.Clear();
789 values.PutInt("id", 1);
790 values.PutInt("age", 18);
791 ret = store->InsertWithConflictResolution(id, "test", values, static_cast<ConflictResolution>(-1));
792 EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
793 EXPECT_EQ(0, id);
794 }