1 /*
2  * Copyright (c) 2024 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 #include <map>
18 #include <string>
19 
20 #include "common.h"
21 #include "connection_pool.h"
22 #include "rdb_errno.h"
23 #include "rdb_predicates.h"
24 #include "sqlite_sql_builder.h"
25 #include "trans_db.h"
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28 namespace Test {
29 class RdbTransDBTest : public testing::Test {
30 public:
31     static void SetUpTestCase(void);
32     static void TearDownTestCase(void);
33     void SetUp();
34     void TearDown();
35 
36 protected:
37     static constexpr const char *CREATE_TABLE = "CREATE TABLE IF NOT EXISTS TEST (id INT PRIMARY KEY, name TEXT, "
38                                                 "extend BLOB, code REAL, years UNLIMITED INT, attachment ASSET, "
39                                                 "attachments ASSETS)";
40     static constexpr const char *DROP_TABLE = "DROP TABLE IF EXISTS TEST";
41     static constexpr const char *TABLE_NAME = "TEST";
42     static std::shared_ptr<ConnectionPool> connPool_;
43     static RdbStoreConfig config_;
44     static ValuesBucket row_;
45     std::shared_ptr<RdbStore> transDB_;
46     std::shared_ptr<Connection> conn_;
47 };
48 std::shared_ptr<ConnectionPool> RdbTransDBTest::connPool_ = nullptr;
49 RdbStoreConfig RdbTransDBTest::config_(RDB_TEST_PATH + "transDb_test.db");
50 ValuesBucket RdbTransDBTest::row_(std::map<std::string, ValueObject>{
51     { "id", ValueObject(1) },
52     { "name", ValueObject("xiaoming") },
53     { "extend", ValueObject(std::vector<uint8_t>(100, 128)) },
54     { "code", ValueObject(3.1415926) },
55     { "years", ValueObject(BigInteger(0, { 128, 225 })) },
56     { "attachment", ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111" }) },
57     { "attachments", ValueObject(ValueObject::Assets{
58                          AssetValue{ .id = "120", .name = "picture2", .hash = "112" },
59                          AssetValue{ .id = "121", .name = "picture3", .hash = "113" },
60                          AssetValue{ .id = "122", .name = "picture4", .hash = "114" },
61                          AssetValue{ .id = "123", .name = "picture5", .hash = "115" }
62                      })
63     }
64 });
65 
SetUpTestCase(void)66 void RdbTransDBTest::SetUpTestCase(void)
67 {
68     config_.SetBundleName("arkdata_test");
69     config_.SetSecurityLevel(OHOS::NativeRdb::SecurityLevel::S1);
70     Connection::Delete(config_);
71     int32_t errCode = E_OK;
72     connPool_ = ConnectionPool::Create(config_, errCode);
73     EXPECT_TRUE(connPool_ != nullptr);
74 }
75 
TearDownTestCase(void)76 void RdbTransDBTest::TearDownTestCase(void)
77 {
78     connPool_ = nullptr;
79     Connection::Delete(config_);
80 }
81 
SetUp()82 void RdbTransDBTest::SetUp()
83 {
84     auto [errCode, conn] = connPool_->CreateTransConn();
85     ASSERT_NE(conn, nullptr);
86     ASSERT_EQ(errCode, E_OK);
87     transDB_ = std::make_shared<TransDB>(conn, config_.GetName());
88     ASSERT_NE(transDB_, nullptr);
89     auto [err, object] = transDB_->Execute(DROP_TABLE);
90     ASSERT_EQ(err, E_OK);
91     std::tie(err, object) = transDB_->Execute(CREATE_TABLE);
92     ASSERT_EQ(err, E_OK);
93     conn_ = conn;
94 }
95 
TearDown()96 void RdbTransDBTest::TearDown()
97 {
98     transDB_ = nullptr;
99     conn_ = nullptr;
100 }
101 
102 /* *
103  * @tc.name: ALREADY_CLOSED_001
104  * @tc.desc: closed db
105  * @tc.type: FUNC
106  */
107 HWTEST_F(RdbTransDBTest, ALREADY_CLOSED_001, TestSize.Level1)
108 {
109     conn_ = nullptr;
110     ValuesBucket row = row_;
111     int32_t changed = 0;
112     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
113     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
114     std::tie(errCode, changed) = transDB_->Update(TABLE_NAME, row);
115     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
116     errCode = transDB_->Delete(changed, TABLE_NAME);
117     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
118     auto resultSet = transDB_->QueryByStep("select * from TEST");
119     ASSERT_NE(resultSet, nullptr);
120     errCode = resultSet->GoToNextRow();
121     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
122     resultSet = transDB_->QuerySql("select * from TEST");
123     ASSERT_NE(resultSet, nullptr);
124     errCode = resultSet->GoToNextRow();
125     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
126 }
127 
128 /* *
129  * @tc.name: ALREADY_CLOSED_002
130  * @tc.desc: closed db
131  * @tc.type: FUNC
132  */
133 HWTEST_F(RdbTransDBTest, ALREADY_CLOSED_002, TestSize.Level1)
134 {
135     ValuesBucket row = row_;
136     int32_t changed = 0;
137     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
138     ASSERT_EQ(errCode, E_OK);
139     auto resultSet = transDB_->QueryByStep("select * from TEST");
140     ASSERT_NE(resultSet, nullptr);
141     errCode = resultSet->GoToNextRow();
142     ASSERT_EQ(errCode, E_OK);
143     conn_ = nullptr;
144     resultSet->Close();
145     errCode = transDB_->Delete(changed, TABLE_NAME);
146     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
147     errCode = resultSet->GoToNextRow();
148     ASSERT_EQ(errCode, E_ALREADY_CLOSED);
149 }
150 
151 /* *
152  * @tc.name: Insert_NEW_001
153  * @tc.desc: insert into test(...) values(?)
154  * @tc.type: FUNC
155  */
156 HWTEST_F(RdbTransDBTest, Insert_NEW_001, TestSize.Level1)
157 {
158     ValuesBucket row = row_;
159     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
160     ASSERT_EQ(errCode, E_OK);
161     ASSERT_EQ(rowId, 1);
162     auto resultSet = transDB_->QueryByStep("select * from TEST");
163     ASSERT_NE(resultSet, nullptr);
164     errCode = resultSet->GoToNextRow();
165     ASSERT_EQ(errCode, E_OK);
166     RowEntity rowEntity;
167     errCode = resultSet->GetRow(rowEntity);
168     ASSERT_EQ(errCode, E_OK);
169     ASSERT_TRUE(row.values_ == rowEntity.Get());
170 }
171 
172 /* *
173  * @tc.name: Insert_NEW_002
174  * @tc.desc: insert or replace into test(...) values(?)
175  * @tc.type: FUNC
176  */
177 HWTEST_F(RdbTransDBTest, Insert_NEW_002, TestSize.Level1)
178 {
179     ValuesBucket row = row_;
180     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
181     ASSERT_EQ(errCode, E_OK);
182     ASSERT_EQ(rowId, 1);
183     row.Put("name", "xiaohua");
184     std::tie(errCode, rowId) = transDB_->Insert(TABLE_NAME, row, ConflictResolution::ON_CONFLICT_REPLACE);
185     ASSERT_EQ(errCode, E_INVALID_ARGS);
186     row.Put("attachments", ValueObject());
187     std::tie(errCode, rowId) = transDB_->Insert(TABLE_NAME, row, ConflictResolution::ON_CONFLICT_REPLACE);
188     ASSERT_EQ(errCode, E_OK);
189     auto resultSet = transDB_->QueryByStep("select * from TEST");
190     ASSERT_NE(resultSet, nullptr);
191     errCode = resultSet->GoToNextRow();
192     ASSERT_EQ(errCode, E_OK);
193     RowEntity rowEntity;
194     errCode = resultSet->GetRow(rowEntity);
195     ASSERT_EQ(errCode, E_OK);
196     ASSERT_TRUE(row.values_ == rowEntity.Get());
197 }
198 
199 /* *
200  * @tc.name: Insert_NEW_003
201  * @tc.desc: insert or ignore into test(...) values(?)
202  * @tc.type: FUNC
203  */
204 HWTEST_F(RdbTransDBTest, Insert_NEW_003, TestSize.Level1)
205 {
206     ValuesBucket row = row_;
207     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
208     ASSERT_EQ(errCode, E_OK);
209     ASSERT_EQ(rowId, 1);
210     row.Put("name", "xiaohua");
211     std::tie(errCode, rowId) = transDB_->Insert(TABLE_NAME, row, ConflictResolution::ON_CONFLICT_IGNORE);
212     ASSERT_EQ(errCode, E_OK);
213     auto resultSet = transDB_->QueryByStep("select * from TEST");
214     ASSERT_NE(resultSet, nullptr);
215     errCode = resultSet->GoToNextRow();
216     ASSERT_EQ(errCode, E_OK);
217     RowEntity rowEntity;
218     errCode = resultSet->GetRow(rowEntity);
219     ASSERT_EQ(errCode, E_OK);
220     row = row_;
221     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachment"], AssetValue::STATUS_INSERT);
222     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachments"], AssetValue::STATUS_INSERT);
223     ASSERT_TRUE(row.values_ == rowEntity.Get());
224 }
225 
226 /* *
227  * @tc.name: Insert_NEW_003
228  * @tc.desc: insert or fail into test(...) values(?)
229  * @tc.type: FUNC
230  */
231 HWTEST_F(RdbTransDBTest, Insert_NEW_004, TestSize.Level1)
232 {
233     ValuesBucket row = row_;
234     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
235     ASSERT_EQ(errCode, E_OK);
236     ASSERT_EQ(rowId, 1);
237     row.Put("name", "xiaohua");
238     std::tie(errCode, rowId) = transDB_->Insert(TABLE_NAME, row, ConflictResolution::ON_CONFLICT_FAIL);
239     ASSERT_EQ(errCode, E_SQLITE_CONSTRAINT);
240     auto resultSet = transDB_->QueryByStep("select * from TEST");
241     ASSERT_NE(resultSet, nullptr);
242     errCode = resultSet->GoToNextRow();
243     ASSERT_EQ(errCode, E_OK);
244     RowEntity rowEntity;
245     errCode = resultSet->GetRow(rowEntity);
246     ASSERT_EQ(errCode, E_OK);
247     row = row_;
248     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachment"], AssetValue::STATUS_INSERT);
249     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachments"], AssetValue::STATUS_INSERT);
250     ASSERT_TRUE(row.values_ == rowEntity.Get());
251 }
252 
253 /* *
254  * @tc.name: Insert_NEW_003
255  * @tc.desc: insert or abort into test(...) values(?)
256  * @tc.type: FUNC
257  */
258 HWTEST_F(RdbTransDBTest, Insert_NEW_005, TestSize.Level1)
259 {
260     ValuesBucket row = row_;
261     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
262     ASSERT_EQ(errCode, E_OK);
263     ASSERT_EQ(rowId, 1);
264     row.Put("name", "xiaohua");
265     std::tie(errCode, rowId) = transDB_->Insert(TABLE_NAME, row, ConflictResolution::ON_CONFLICT_ABORT);
266     ASSERT_EQ(errCode, E_SQLITE_CONSTRAINT);
267     auto resultSet = transDB_->QueryByStep("select * from TEST");
268     ASSERT_NE(resultSet, nullptr);
269     errCode = resultSet->GoToNextRow();
270     ASSERT_EQ(errCode, E_OK);
271     RowEntity rowEntity;
272     errCode = resultSet->GetRow(rowEntity);
273     ASSERT_EQ(errCode, E_OK);
274     row = row_;
275     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachment"], AssetValue::STATUS_INSERT);
276     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachments"], AssetValue::STATUS_INSERT);
277     ASSERT_TRUE(row.values_ == rowEntity.Get());
278 }
279 
280 /* *
281  * @tc.name: Insert_NEW_006
282  * @tc.desc: insert or rollback into test(...) values(?)
283  * @tc.type: FUNC
284  */
285 HWTEST_F(RdbTransDBTest, Insert_NEW_006, TestSize.Level1)
286 {
287     ValuesBucket row = row_;
288     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
289     ASSERT_EQ(errCode, E_OK);
290     ASSERT_EQ(rowId, 1);
291     row.Put("name", "xiaohua");
292     std::tie(errCode, rowId) = transDB_->Insert(TABLE_NAME, row, ConflictResolution::ON_CONFLICT_ROLLBACK);
293     ASSERT_EQ(errCode, E_SQLITE_CONSTRAINT);
294     auto resultSet = transDB_->QueryByStep("select * from TEST");
295     ASSERT_NE(resultSet, nullptr);
296     errCode = resultSet->GoToNextRow();
297     ASSERT_EQ(errCode, E_OK);
298     RowEntity rowEntity;
299     errCode = resultSet->GetRow(rowEntity);
300     ASSERT_EQ(errCode, E_OK);
301     row = row_;
302     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachment"], AssetValue::STATUS_INSERT);
303     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachments"], AssetValue::STATUS_INSERT);
304     ASSERT_TRUE(row.values_ == rowEntity.Get());
305 }
306 
307 /* *
308  * @tc.name: Insert_001
309  * @tc.desc: insert into test(...) values(?)
310  * @tc.type: FUNC
311  */
312 HWTEST_F(RdbTransDBTest, Insert_001, TestSize.Level1)
313 {
314     int64_t rowId = -1;
315     ValuesBucket row = row_;
316     auto errCode = transDB_->Insert(rowId, TABLE_NAME, row);
317     ASSERT_EQ(errCode, E_OK);
318     ASSERT_EQ(rowId, 1);
319     auto resultSet = transDB_->QueryByStep("select * from TEST");
320     ASSERT_NE(resultSet, nullptr);
321     errCode = resultSet->GoToNextRow();
322     ASSERT_EQ(errCode, E_OK);
323     RowEntity rowEntity;
324     errCode = resultSet->GetRow(rowEntity);
325     ASSERT_EQ(errCode, E_OK);
326     ASSERT_TRUE(row.values_ == rowEntity.Get());
327 }
328 
329 /* *
330  * @tc.name: Insert_002
331  * @tc.desc: insert into test(...) values(?)
332  * @tc.type: FUNC
333  */
334 HWTEST_F(RdbTransDBTest, Insert_002, TestSize.Level1)
335 {
336     int64_t rowId = -1;
337     ValuesBucket row = row_;
338     auto errCode = transDB_->Insert(rowId, TABLE_NAME, row);
339     ASSERT_EQ(errCode, E_OK);
340     ASSERT_EQ(rowId, 1);
341     errCode = transDB_->Insert(rowId, TABLE_NAME, row);
342     ASSERT_EQ(errCode, E_SQLITE_CONSTRAINT);
343 }
344 
345 /* *
346  * @tc.name: InsertWithConflictResolution_001
347  * @tc.desc: insert or replace into test(...) values(?)
348  * @tc.type: FUNC
349  */
350 HWTEST_F(RdbTransDBTest, InsertWithConflictResolution_001, TestSize.Level1)
351 {
352     ValuesBucket row = row_;
353     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
354     ASSERT_EQ(errCode, E_OK);
355     ASSERT_EQ(rowId, 1);
356     row.Put("name", "xiaohua");
357     errCode = transDB_->InsertWithConflictResolution(rowId, TABLE_NAME, row, ConflictResolution::ON_CONFLICT_REPLACE);
358     ASSERT_EQ(errCode, E_INVALID_ARGS);
359     row.Put("attachments", ValueObject());
360     errCode = transDB_->InsertWithConflictResolution(rowId, TABLE_NAME, row, ConflictResolution::ON_CONFLICT_REPLACE);
361     ASSERT_EQ(errCode, E_OK);
362     auto resultSet = transDB_->QueryByStep("select * from TEST");
363     ASSERT_NE(resultSet, nullptr);
364     errCode = resultSet->GoToNextRow();
365     ASSERT_EQ(errCode, E_OK);
366     RowEntity rowEntity;
367     errCode = resultSet->GetRow(rowEntity);
368     ASSERT_EQ(errCode, E_OK);
369     ASSERT_TRUE(row.values_ == rowEntity.Get());
370 }
371 
372 /* *
373  * @tc.name: Replace_001
374  * @tc.desc: insert or replace into test(...) values(?)
375  * @tc.type: FUNC
376  */
377 HWTEST_F(RdbTransDBTest, Replace_001, TestSize.Level1)
378 {
379     ValuesBucket row = row_;
380     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
381     ASSERT_EQ(errCode, E_OK);
382     ASSERT_EQ(rowId, 1);
383     row.Put("name", "xiaohua");
384     errCode = transDB_->Replace(rowId, TABLE_NAME, row);
385     ASSERT_EQ(errCode, E_INVALID_ARGS);
386     row.Put("attachments", ValueObject());
387     errCode = transDB_->Replace(rowId, TABLE_NAME, row);
388     ASSERT_EQ(errCode, E_OK);
389     auto resultSet = transDB_->QueryByStep("select * from TEST");
390     ASSERT_NE(resultSet, nullptr);
391     errCode = resultSet->GoToNextRow();
392     ASSERT_EQ(errCode, E_OK);
393     RowEntity rowEntity;
394     errCode = resultSet->GetRow(rowEntity);
395     ASSERT_EQ(errCode, E_OK);
396     ASSERT_TRUE(row.values_ == rowEntity.Get());
397 }
398 
399 /* *
400  * @tc.name: BatchInsert
401  * @tc.desc: insert Normal ValuesBucket to db
402  * @tc.type: FUNC
403  */
404 HWTEST_F(RdbTransDBTest, BatchInsert_001, TestSize.Level1)
405 {
406     int64_t changedNum = -1;
407     std::vector<ValuesBucket> rows;
408     for (int i = 0; i < 20; i++) {
409         ValuesBucket row = row_;
410         row.Put("id", i);
411         row.Put("name", "xiaoming_" + std::to_string(i));
412         row.Put("years", BigInteger(i % 2, { 128, 225 }));
413         rows.push_back(std::move(row));
414     }
415     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
416     ASSERT_EQ(errCode, E_OK);
417     ASSERT_EQ(changedNum, 20);
418     auto resultSet = transDB_->QueryByStep("select * from TEST order by id");
419     ASSERT_NE(resultSet, nullptr);
420     size_t index = 0;
421     while (resultSet->GoToNextRow() == E_OK && index < rows.size()) {
422         RowEntity rowEntity;
423         errCode = resultSet->GetRow(rowEntity);
424         ASSERT_EQ(errCode, E_OK);
425         auto row = rowEntity.Steal();
426         SqliteSqlBuilder::UpdateAssetStatus(rows[index].values_["attachment"], AssetValue::STATUS_INSERT);
427         SqliteSqlBuilder::UpdateAssetStatus(rows[index].values_["attachments"], AssetValue::STATUS_INSERT);
428         ASSERT_TRUE(rows[index].values_ == row);
429         index++;
430     }
431     int32_t rowCount = 0;
432     errCode = resultSet->GetRowCount(rowCount);
433     ASSERT_EQ(errCode, E_OK);
434     ASSERT_EQ(rowCount, rows.size());
435 }
436 
437 /* *
438  * @tc.name: BatchInsert
439  * @tc.desc: insert RefRows to db
440  * @tc.type: FUNC
441  */
442 HWTEST_F(RdbTransDBTest, BatchInsert_002, TestSize.Level1)
443 {
444     ValuesBuckets rows;
445     for (int i = 0; i < 20; i++) {
446         ValuesBucket row = row_;
447         row.Put("id", i);
448         row.Put("name", "xiaoming_" + std::to_string(i));
449         row.Put("years", BigInteger(i % 2, { 128, 225 }));
450         rows.Put(row);
451     }
452     auto [errCode, changedNum] = transDB_->BatchInsert(TABLE_NAME, rows);
453     ASSERT_EQ(errCode, E_OK);
454     ASSERT_EQ(changedNum, 20);
455     auto resultSet = transDB_->QueryByStep("select * from TEST order by id");
456     ASSERT_NE(resultSet, nullptr);
457     size_t index = 0;
458     while (resultSet->GoToNextRow() == E_OK) {
459         RowEntity rowEntity;
460         errCode = resultSet->GetRow(rowEntity);
461         ASSERT_EQ(errCode, E_OK);
462         auto row = rowEntity.Steal();
463         for (auto &[key, value] : row) {
464             auto [ret, val] = rows.Get(index, ValuesBuckets::FieldType(key));
465             ASSERT_EQ(ret, E_OK);
466             ASSERT_TRUE(val.get() == value);
467         }
468         index++;
469     }
470     int32_t rowCount = 0;
471     errCode = resultSet->GetRowCount(rowCount);
472     ASSERT_EQ(errCode, E_OK);
473     ASSERT_EQ(rows.RowSize(), size_t(rowCount));
474 }
475 
476 /* *
477  * @tc.name: Update_001
478  * @tc.desc: update test set(id=?,...)
479  * @tc.type: FUNC
480  */
481 HWTEST_F(RdbTransDBTest, Update_001, TestSize.Level1)
482 {
483     ValuesBucket row = row_;
484     int32_t changed = -1;
485     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
486     ASSERT_EQ(errCode, E_OK);
487     ASSERT_EQ(rowId, 1);
488     row.Put("name", "xiaohua");
489     row.Put("attachment",
490         ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111", .path = "/data/test" }));
491     std::tie(errCode, changed) = transDB_->Update(TABLE_NAME, row);
492     ASSERT_EQ(errCode, E_OK);
493     auto resultSet = transDB_->QueryByStep("select * from TEST");
494     ASSERT_NE(resultSet, nullptr);
495     errCode = resultSet->GoToNextRow();
496     ASSERT_EQ(errCode, E_OK);
497     RowEntity rowEntity;
498     errCode = resultSet->GetRow(rowEntity);
499     ASSERT_EQ(errCode, E_OK);
500     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachment"], AssetValue::STATUS_UPDATE);
501     ASSERT_TRUE(row.values_ == rowEntity.Get());
502 }
503 
504 /* *
505  * @tc.name: Update_002
506  * @tc.desc: update test set(id=?,...) where id > ? and  id < ?
507  * @tc.type: FUNC
508  */
509 HWTEST_F(RdbTransDBTest, Update_002, TestSize.Level1)
510 {
511     int64_t changedNum = -1;
512     std::vector<ValuesBucket> rows;
513     for (int i = 0; i < 20; i++) {
514         ValuesBucket row = row_;
515         row.Put("id", i);
516         row.Put("name", "xiaoming_" + std::to_string(i));
517         row.Put("years", BigInteger(i % 2, { 128, 225 }));
518         rows.push_back(std::move(row));
519     }
520     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
521     ASSERT_EQ(errCode, E_OK);
522     ASSERT_EQ(changedNum, 20);
523     auto updateRow = row_;
524     updateRow.values_.erase("id");
525     updateRow.Put("attachment",
526         ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111", .path = "/data/test" }));
527     int32_t updatedNum = -1;
528     std::tie(errCode, updatedNum) = transDB_->Update(TABLE_NAME, updateRow, "id > ? and  id < ?", { 0, 10 });
529     ASSERT_EQ(errCode, E_OK);
530     ASSERT_EQ(updatedNum, 9);
531     auto resultSet = transDB_->QueryByStep("select * from TEST where id > ? and  id < ? order by id", { 0, 10 });
532     ASSERT_NE(resultSet, nullptr);
533     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachment"], AssetValue::STATUS_UPDATE);
534     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachments"], AssetValue::STATUS_INSERT);
535     size_t index = 0;
536     while (resultSet->GoToNextRow() == E_OK) {
537         RowEntity rowEntity;
538         errCode = resultSet->GetRow(rowEntity);
539         ASSERT_EQ(errCode, E_OK);
540         auto row = rowEntity.Steal();
541         row.erase("id");
542         ASSERT_TRUE(updateRow.values_ == row);
543         index++;
544     }
545     ASSERT_EQ(index, 9);
546 }
547 
548 /* *
549  * @tc.name: Update_003
550  * @tc.desc: update test set(id=?,...) where id > ? and  id < ?
551  * @tc.type: FUNC
552  */
553 HWTEST_F(RdbTransDBTest, Update_003, TestSize.Level1)
554 {
555     int64_t changedNum = -1;
556     std::vector<ValuesBucket> rows;
557     for (int i = 0; i < 20; i++) {
558         ValuesBucket row = row_;
559         row.Put("id", i);
560         row.Put("name", "xiaoming_" + std::to_string(i));
561         row.Put("years", BigInteger(i % 2, { 128, 225 }));
562         rows.push_back(std::move(row));
563     }
564     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
565     ASSERT_EQ(errCode, E_OK);
566     ASSERT_EQ(changedNum, 20);
567     auto updateRow = row_;
568     updateRow.values_.erase("id");
569     updateRow.Put("attachment",
570         ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111", .path = "/data/test" }));
571     int32_t updatedNum = -1;
572     std::tie(errCode, updatedNum) = transDB_->Update(TABLE_NAME, updateRow, "id > ? and  id < ?", { 0, 10 },
573         ConflictResolution::ON_CONFLICT_ROLLBACK);
574     ASSERT_EQ(errCode, E_OK);
575     ASSERT_EQ(updatedNum, 9);
576     auto resultSet = transDB_->QueryByStep("select * from TEST where id > ? and  id < ? order by id", { 0, 10 });
577     ASSERT_NE(resultSet, nullptr);
578     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachment"], AssetValue::STATUS_UPDATE);
579     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachments"], AssetValue::STATUS_INSERT);
580     size_t index = 0;
581     while (resultSet->GoToNextRow() == E_OK) {
582         RowEntity rowEntity;
583         errCode = resultSet->GetRow(rowEntity);
584         ASSERT_EQ(errCode, E_OK);
585         auto row = rowEntity.Steal();
586         row.erase("id");
587         ASSERT_TRUE(updateRow.values_ == row);
588         index++;
589     }
590     ASSERT_EQ(index, 9);
591 }
592 
593 /* *
594  * @tc.name: Update_004
595  * @tc.desc: update test set(id=?,...)
596  * @tc.type: FUNC
597  */
598 HWTEST_F(RdbTransDBTest, Update_004, TestSize.Level1)
599 {
600     ValuesBucket row = row_;
601     int32_t changed = -1;
602     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
603     ASSERT_EQ(errCode, E_OK);
604     ASSERT_EQ(rowId, 1);
605     row.Put("name", "xiaohua");
606     row.Put("attachment",
607         ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111", .path = "/data/test" }));
608     errCode = transDB_->Update(changed, TABLE_NAME, row);
609     ASSERT_EQ(errCode, E_OK);
610     auto resultSet = transDB_->QueryByStep("select * from TEST");
611     ASSERT_NE(resultSet, nullptr);
612     errCode = resultSet->GoToNextRow();
613     ASSERT_EQ(errCode, E_OK);
614     RowEntity rowEntity;
615     errCode = resultSet->GetRow(rowEntity);
616     ASSERT_EQ(errCode, E_OK);
617     SqliteSqlBuilder::UpdateAssetStatus(row.values_["attachment"], AssetValue::STATUS_UPDATE);
618     ASSERT_TRUE(row.values_ == rowEntity.Get());
619 }
620 
621 /* *
622  * @tc.name: Update_005
623  * @tc.desc: update test set(id=?,...) where id > ? and  id < ?
624  * @tc.type: FUNC
625  */
626 HWTEST_F(RdbTransDBTest, Update_005, TestSize.Level1)
627 {
628     int64_t changedNum = -1;
629     std::vector<ValuesBucket> rows;
630     for (int i = 0; i < 20; i++) {
631         ValuesBucket row = row_;
632         row.Put("id", i);
633         row.Put("name", "xiaoming_" + std::to_string(i));
634         row.Put("years", BigInteger(i % 2, { 128, 225 }));
635         rows.push_back(std::move(row));
636     }
637     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
638     ASSERT_EQ(errCode, E_OK);
639     ASSERT_EQ(changedNum, 20);
640     auto updateRow = row_;
641     updateRow.values_.erase("id");
642     updateRow.Put("attachment",
643         ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111", .path = "/data/test" }));
644     int32_t updatedNum = -1;
645     RdbPredicates rdbPredicates(TABLE_NAME);
646     rdbPredicates.GreaterThan("id", 0);
647     rdbPredicates.And();
648     rdbPredicates.LessThan("id", 10);
649     errCode = transDB_->Update(updatedNum, updateRow, rdbPredicates);
650     ASSERT_EQ(errCode, E_OK);
651     ASSERT_EQ(updatedNum, 9);
652     auto resultSet = transDB_->QueryByStep(rdbPredicates);
653     ASSERT_NE(resultSet, nullptr);
654     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachment"], AssetValue::STATUS_UPDATE);
655     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachments"], AssetValue::STATUS_INSERT);
656     size_t index = 0;
657     while (resultSet->GoToNextRow() == E_OK) {
658         RowEntity rowEntity;
659         errCode = resultSet->GetRow(rowEntity);
660         ASSERT_EQ(errCode, E_OK);
661         auto row = rowEntity.Steal();
662         row.erase("id");
663         ASSERT_TRUE(updateRow.values_ == row);
664         index++;
665     }
666     ASSERT_EQ(index, 9);
667 }
668 
669 /* *
670  * @tc.name: UpdateWithConflictResolution_001
671  * @tc.desc: update test set(id=?,...) where id > ? and  id < ?
672  * @tc.type: FUNC
673  */
674 HWTEST_F(RdbTransDBTest, UpdateWithConflictResolution_001, TestSize.Level1)
675 {
676     int64_t changedNum = -1;
677     std::vector<ValuesBucket> rows;
678     for (int i = 0; i < 20; i++) {
679         ValuesBucket row = row_;
680         row.Put("id", i);
681         row.Put("name", "xiaoming_" + std::to_string(i));
682         row.Put("years", BigInteger(i % 2, { 128, 225 }));
683         rows.push_back(std::move(row));
684     }
685     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
686     ASSERT_EQ(errCode, E_OK);
687     ASSERT_EQ(changedNum, 20);
688     auto updateRow = row_;
689     updateRow.values_.erase("id");
690     updateRow.Put("attachment",
691         ValueObject(AssetValue{ .id = "119", .name = "picture1", .hash = "111", .path = "/data/test" }));
692     int32_t updatedNum = -1;
693     errCode =
694         transDB_->UpdateWithConflictResolution(updatedNum, TABLE_NAME, updateRow, "id > ? and  id < ?", { 0, 10 });
695     ASSERT_EQ(errCode, E_OK);
696     ASSERT_EQ(updatedNum, 9);
697     auto resultSet = transDB_->QueryByStep("select * from TEST where id > ? and  id < ? order by id", { 0, 10 });
698     ASSERT_NE(resultSet, nullptr);
699     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachment"], AssetValue::STATUS_UPDATE);
700     SqliteSqlBuilder::UpdateAssetStatus(updateRow.values_["attachments"], AssetValue::STATUS_INSERT);
701     size_t index = 0;
702     while (resultSet->GoToNextRow() == E_OK) {
703         RowEntity rowEntity;
704         errCode = resultSet->GetRow(rowEntity);
705         ASSERT_EQ(errCode, E_OK);
706         auto row = rowEntity.Steal();
707         row.erase("id");
708         ASSERT_TRUE(updateRow.values_ == row);
709         index++;
710     }
711     ASSERT_EQ(index, 9);
712 }
713 
714 /* *
715  * @tc.name: Delete_001
716  * @tc.desc: delete from test where id > ? and  id < ?
717  * @tc.type: FUNC
718  */
719 HWTEST_F(RdbTransDBTest, Delete_001, TestSize.Level1)
720 {
721     int64_t changedNum = -1;
722     std::vector<ValuesBucket> rows;
723     for (int i = 0; i < 20; i++) {
724         ValuesBucket row = row_;
725         row.Put("id", i);
726         row.Put("name", "xiaoming_" + std::to_string(i));
727         row.Put("years", BigInteger(i % 2, { 128, 225 }));
728         rows.push_back(std::move(row));
729     }
730     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
731     ASSERT_EQ(errCode, E_OK);
732     ASSERT_EQ(changedNum, 20);
733     int32_t deleteNum = -1;
734     RdbPredicates rdbPredicates(TABLE_NAME);
735     rdbPredicates.GreaterThan("id", 0);
736     rdbPredicates.And();
737     rdbPredicates.LessThan("id", 10);
738     errCode = transDB_->Delete(deleteNum, rdbPredicates);
739     ASSERT_EQ(errCode, E_OK);
740     ASSERT_EQ(deleteNum, 9);
741     auto resultSet = transDB_->QueryByStep(rdbPredicates);
742     ASSERT_NE(resultSet, nullptr);
743     int32_t count = -1;
744     errCode = resultSet->GetRowCount(count);
745     ASSERT_EQ(errCode, E_OK);
746     ASSERT_EQ(count, 0);
747 }
748 
749 /* *
750  * @tc.name: Delete_002
751  * @tc.desc: delete from test where id > ? and  id < ?
752  * @tc.type: FUNC
753  */
754 HWTEST_F(RdbTransDBTest, Delete_002, TestSize.Level1)
755 {
756     int64_t changedNum = -1;
757     std::vector<ValuesBucket> rows;
758     for (int i = 0; i < 20; i++) {
759         ValuesBucket row = row_;
760         row.Put("id", i);
761         row.Put("name", "xiaoming_" + std::to_string(i));
762         row.Put("years", BigInteger(i % 2, { 128, 225 }));
763         rows.push_back(std::move(row));
764     }
765     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
766     ASSERT_EQ(errCode, E_OK);
767     ASSERT_EQ(changedNum, 20);
768     int32_t deleteNum = -1;
769     errCode = transDB_->Delete(deleteNum, TABLE_NAME, "id > ? and  id < ?", { 0, 10 });
770     ASSERT_EQ(errCode, E_OK);
771     ASSERT_EQ(deleteNum, 9);
772     auto resultSet = transDB_->QueryByStep("select * from TEST where id > ? and  id < ? order by id", { 0, 10 });
773     ASSERT_NE(resultSet, nullptr);
774     int32_t count = -1;
775     errCode = resultSet->GetRowCount(count);
776     ASSERT_EQ(errCode, E_OK);
777     ASSERT_EQ(count, 0);
778 }
779 
780 /* *
781  * @tc.name: QueryByStep_001
782  * @tc.desc: select id, name, yeas from test where id > ? and  id < ? order by id asc
783  * @tc.type: FUNC
784  */
785 HWTEST_F(RdbTransDBTest, QueryByStep_001, TestSize.Level1)
786 {
787     int64_t changedNum = -1;
788     std::vector<ValuesBucket> rows;
789     for (int i = 0; i < 20; i++) {
790         ValuesBucket row = row_;
791         row.Put("id", i);
792         row.Put("name", "xiaoming_" + std::to_string(i));
793         row.Put("years", BigInteger(i % 2, { 128, 225 }));
794         rows.push_back(std::move(row));
795     }
796     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
797     ASSERT_EQ(errCode, E_OK);
798     ASSERT_EQ(changedNum, 20);
799     RdbPredicates rdbPredicates(TABLE_NAME);
800     rdbPredicates.GreaterThan("id", 0);
801     rdbPredicates.And();
802     rdbPredicates.LessThan("id", 10);
803     rdbPredicates.OrderByAsc("id");
804     auto resultSet = transDB_->QueryByStep(rdbPredicates, { "id", "name", "years" });
805     ASSERT_NE(resultSet, nullptr);
806     int64_t index = 1;
807     while (resultSet->GoToNextRow() == E_OK) {
808         RowEntity rowEntity;
809         errCode = resultSet->GetRow(rowEntity);
810         ASSERT_EQ(errCode, E_OK);
811         auto row = rowEntity.Steal();
812         ASSERT_TRUE(row.size() == 3);
813         ASSERT_TRUE(row["id"] == ValueObject(index));
814         ASSERT_TRUE(row["name"] == ValueObject("xiaoming_" + std::to_string(index)));
815         ASSERT_TRUE(row["years"] == ValueObject(BigInteger(index % 2, { 128, 225 })));
816         index++;
817     }
818     int32_t count = -1;
819     errCode = resultSet->GetRowCount(count);
820     ASSERT_EQ(errCode, E_OK);
821     ASSERT_EQ(count, 9);
822 }
823 
824 /* *
825  * @tc.name: Query_001
826  * @tc.desc: select id, name, yeas from test where id > ? and  id < ? order by id asc
827  * @tc.type: FUNC
828  */
829 HWTEST_F(RdbTransDBTest, Query_001, TestSize.Level1)
830 {
831     int64_t changedNum = -1;
832     std::vector<ValuesBucket> rows;
833     for (int i = 0; i < 20; i++) {
834         ValuesBucket row = row_;
835         row.Put("id", i);
836         row.Put("name", "xiaoming_" + std::to_string(i));
837         row.Put("years", BigInteger(i % 2, { 128, 225 }));
838         rows.push_back(std::move(row));
839     }
840     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
841     ASSERT_EQ(errCode, E_OK);
842     ASSERT_EQ(changedNum, 20);
843     RdbPredicates rdbPredicates(TABLE_NAME);
844     rdbPredicates.GreaterThan("id", 0);
845     rdbPredicates.And();
846     rdbPredicates.LessThan("id", 10);
847     rdbPredicates.OrderByAsc("id");
848     auto resultSet = transDB_->Query(rdbPredicates, { "id", "name", "years" });
849     ASSERT_NE(resultSet, nullptr);
850     int64_t index = 1;
851     while (resultSet->GoToNextRow() == E_OK) {
852         RowEntity rowEntity;
853         errCode = resultSet->GetRow(rowEntity);
854         ASSERT_EQ(errCode, E_OK);
855         auto row = rowEntity.Steal();
856         ASSERT_TRUE(row.size() == 3);
857         ASSERT_TRUE(row["id"] == ValueObject(index));
858         ASSERT_TRUE(row["name"] == ValueObject("xiaoming_" + std::to_string(index)));
859         ASSERT_TRUE(row["years"] == ValueObject(BigInteger(index % 2, { 128, 225 })));
860         index++;
861     }
862     int32_t count = -1;
863     errCode = resultSet->GetRowCount(count);
864     ASSERT_EQ(errCode, E_OK);
865     ASSERT_EQ(count, 9);
866 }
867 
868 /* *
869  * @tc.name: QuerySql_001
870  * @tc.desc: select * from test where id > ? and  id < ? order by id asc
871  * @tc.type: FUNC
872  */
873 HWTEST_F(RdbTransDBTest, QuerySql_001, TestSize.Level1)
874 {
875     int64_t changedNum = -1;
876     std::vector<ValuesBucket> rows;
877     for (int i = 0; i < 20; i++) {
878         ValuesBucket row = row_;
879         row.Put("id", i);
880         row.Put("name", "xiaoming_" + std::to_string(i));
881         row.Put("years", BigInteger(i % 2, { 128, 225 }));
882         rows.push_back(std::move(row));
883     }
884     auto errCode = transDB_->BatchInsert(changedNum, TABLE_NAME, rows);
885     ASSERT_EQ(errCode, E_OK);
886     ASSERT_EQ(changedNum, 20);
887     auto resultSet = transDB_->QuerySql("select * from TEST where id > ? and  id < ? order by id", { 0, 10 });
888     ASSERT_NE(resultSet, nullptr);
889     int64_t index = 1;
890     while (resultSet->GoToNextRow() == E_OK) {
891         RowEntity rowEntity;
892         errCode = resultSet->GetRow(rowEntity);
893         ASSERT_EQ(errCode, E_OK);
894         auto row = rowEntity.Steal();
895         ASSERT_TRUE(row["id"] == ValueObject(index));
896         ASSERT_TRUE(row["name"] == ValueObject("xiaoming_" + std::to_string(index)));
897         ASSERT_TRUE(row["years"] == ValueObject(BigInteger(index % 2, { 128, 225 })));
898         index++;
899     }
900     int32_t count = -1;
901     errCode = resultSet->GetRowCount(count);
902     ASSERT_EQ(errCode, E_OK);
903     ASSERT_EQ(count, 9);
904 }
905 
906 /* *
907  * @tc.name: Execute_001
908  * @tc.desc: PRAGMA user_version
909  * @tc.type: FUNC
910  */
911 HWTEST_F(RdbTransDBTest, Execute_PRAGMA_001, TestSize.Level1)
912 {
913     auto [errCode, value] = transDB_->Execute("PRAGMA user_version=100");
914     ASSERT_EQ(errCode, E_OK);
915     std::tie(errCode, value) = transDB_->Execute("PRAGMA user_version");
916     ASSERT_EQ(errCode, E_OK);
917     ASSERT_TRUE(value == ValueObject(100));
918 }
919 
920 /* *
921  * @tc.name: Execute_DDL_001
922  * @tc.desc: PRAGMA user_version
923  * @tc.type: FUNC
924  */
925 HWTEST_F(RdbTransDBTest, Execute_DDL_001, TestSize.Level1)
926 {
927     auto [errCode, value] = transDB_->Execute("PRAGMA schema_version");
928     ASSERT_EQ(errCode, E_OK);
929     ASSERT_NE(value, ValueObject());
930     auto oldVer = value;
931     std::tie(errCode, value) = transDB_->Execute("CREATE TABLE IF NOT EXISTS TEST1 (id INT PRIMARY KEY, name TEXT)");
932     ASSERT_EQ(errCode, E_OK);
933     ASSERT_TRUE(value == ValueObject());
934     std::tie(errCode, value) = transDB_->Execute("DROP TABLE IF EXISTS TEST1");
935     ASSERT_EQ(errCode, E_OK);
936     ASSERT_TRUE(value == ValueObject());
937     std::tie(errCode, value) = transDB_->Execute("PRAGMA schema_version");
938     ASSERT_EQ(errCode, E_OK);
939     ASSERT_FALSE(value == ValueObject());
940     ASSERT_FALSE(value == oldVer);
941 }
942 
943 /* *
944  * @tc.name: Execute_Insert_001
945  * @tc.desc: INSERT INTO TEST(id, name) VALUES(?,?)
946  * @tc.type: FUNC
947  */
948 HWTEST_F(RdbTransDBTest, Execute_Insert_001, TestSize.Level1)
949 {
950     auto [errCode, value] = transDB_->Execute("INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
951     ASSERT_EQ(errCode, E_OK);
952     ASSERT_EQ(value, ValueObject(1));
953     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
954     ASSERT_NE(resultSet, nullptr);
955     errCode = resultSet->GoToNextRow();
956     ASSERT_EQ(errCode, E_OK);
957     RowEntity rowEntity;
958     errCode = resultSet->GetRow(rowEntity);
959     ASSERT_EQ(errCode, E_OK);
960     auto row = rowEntity.Steal();
961     ASSERT_TRUE(row["id"] == ValueObject(100));
962     ASSERT_TRUE(row["name"] == ValueObject("xiaohong"));
963     ASSERT_TRUE(row["years"] == ValueObject());
964     int32_t count = -1;
965     errCode = resultSet->GetRowCount(count);
966     ASSERT_EQ(errCode, E_OK);
967     ASSERT_EQ(count, 1);
968 }
969 
970 /* *
971  * @tc.name: Execute_Insert_002
972  * @tc.desc: INSERT OR IGNORE INTO TEST(id, name) VALUES(?,?)
973  * @tc.type: FUNC
974  */
975 HWTEST_F(RdbTransDBTest, Execute_Insert_002, TestSize.Level1)
976 {
977     auto [errCode, value] = transDB_->Execute("INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
978     ASSERT_EQ(errCode, E_OK);
979     ASSERT_EQ(value, ValueObject(1));
980     std::tie(errCode, value) = transDB_->Execute(
981         "INSERT OR IGNORE INTO TEST(id, name) VALUES (?,?)", { 100, "xiaoming" });
982     ASSERT_EQ(errCode, E_OK);
983     ASSERT_EQ(value, ValueObject(-1));
984     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
985     ASSERT_NE(resultSet, nullptr);
986     errCode = resultSet->GoToNextRow();
987     ASSERT_EQ(errCode, E_OK);
988     RowEntity rowEntity;
989     errCode = resultSet->GetRow(rowEntity);
990     ASSERT_EQ(errCode, E_OK);
991     auto row = rowEntity.Steal();
992     ASSERT_TRUE(row["id"] == ValueObject(100));
993     ASSERT_TRUE(row["name"] == ValueObject("xiaohong"));
994     int32_t count = -1;
995     errCode = resultSet->GetRowCount(count);
996     ASSERT_EQ(errCode, E_OK);
997     ASSERT_EQ(count, 1);
998 }
999 
1000 /* *
1001  * @tc.name: Execute_Update_001
1002  * @tc.desc: UPDATE TEST SET id=?, name=?
1003  * @tc.type: FUNC
1004  */
1005 HWTEST_F(RdbTransDBTest, Execute_Update_001, TestSize.Level1)
1006 {
1007     auto [errCode, value] = transDB_->Execute("INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
1008     ASSERT_EQ(errCode, E_OK);
1009     ASSERT_EQ(value, ValueObject(1));
1010     std::tie(errCode, value) = transDB_->Execute("UPDATE TEST SET id=?, name=?", { 100, "xiaoming" });
1011     ASSERT_EQ(errCode, E_OK);
1012     ASSERT_EQ(value, ValueObject(1));
1013     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1014     ASSERT_NE(resultSet, nullptr);
1015     errCode = resultSet->GoToNextRow();
1016     ASSERT_EQ(errCode, E_OK);
1017     RowEntity rowEntity;
1018     errCode = resultSet->GetRow(rowEntity);
1019     ASSERT_EQ(errCode, E_OK);
1020     auto row = rowEntity.Steal();
1021     ASSERT_TRUE(row["id"] == ValueObject(100));
1022     ASSERT_TRUE(row["name"] == ValueObject("xiaoming"));
1023     int32_t count = -1;
1024     errCode = resultSet->GetRowCount(count);
1025     ASSERT_EQ(errCode, E_OK);
1026     ASSERT_EQ(count, 1);
1027 }
1028 
1029 /* *
1030  * @tc.name: Execute_Transaction_001
1031  * @tc.desc: UPDATE TEST SET(id=?, name=?)
1032  * @tc.type: FUNC
1033  */
1034 HWTEST_F(RdbTransDBTest, Execute_Transaction_001, TestSize.Level1)
1035 {
1036     auto [errCode, value] = transDB_->Execute("BEGIN");
1037     ASSERT_EQ(errCode, E_OK);
1038     ASSERT_TRUE(value == ValueObject());
1039     std::tie(errCode, value) = transDB_->Execute("INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
1040     ASSERT_EQ(errCode, E_OK);
1041     ASSERT_TRUE(value == ValueObject(1));
1042     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1043     ASSERT_NE(resultSet, nullptr);
1044     int32_t count = -1;
1045     errCode = resultSet->GetRowCount(count);
1046     ASSERT_EQ(errCode, E_OK);
1047     ASSERT_EQ(count, 1);
1048     std::tie(errCode, value) = transDB_->Execute("ROLLBACK");
1049     ASSERT_EQ(errCode, E_OK);
1050     resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1051     ASSERT_NE(resultSet, nullptr);
1052     count = -1;
1053     errCode = resultSet->GetRowCount(count);
1054     ASSERT_EQ(errCode, E_OK);
1055     ASSERT_EQ(count, 0);
1056 }
1057 
1058 /* *
1059  * @tc.name: Execute_Transaction_002
1060  * @tc.desc: BEGIN, COMMIT, ROLLBACK
1061  * @tc.type: FUNC
1062  */
1063 HWTEST_F(RdbTransDBTest, Execute_Transaction_002, TestSize.Level1)
1064 {
1065     auto [errCode, value] = transDB_->Execute("BEGIN");
1066     ASSERT_EQ(errCode, E_OK);
1067     ASSERT_TRUE(value == ValueObject());
1068     std::tie(errCode, value) = transDB_->Execute("INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
1069     ASSERT_EQ(errCode, E_OK);
1070     ASSERT_TRUE(value == ValueObject(1));
1071     std::tie(errCode, value) = transDB_->Execute("COMMIT");
1072     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1073     ASSERT_NE(resultSet, nullptr);
1074     int32_t count = -1;
1075     errCode = resultSet->GetRowCount(count);
1076     ASSERT_EQ(errCode, E_OK);
1077     ASSERT_EQ(count, 1);
1078     std::tie(errCode, value) = transDB_->Execute("ROLLBACK");
1079     resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1080     ASSERT_NE(resultSet, nullptr);
1081     count = -1;
1082     errCode = resultSet->GetRowCount(count);
1083     ASSERT_EQ(errCode, E_OK);
1084     ASSERT_EQ(count, 1);
1085 }
1086 
1087 /* *
1088  * @tc.name: Execute_INVALID_001
1089  * @tc.desc: attach detach select and etc.
1090  * @tc.type: FUNC
1091  */
1092 HWTEST_F(RdbTransDBTest, Execute_INVALID_001, TestSize.Level1)
1093 {
1094     auto [errCode, value] = transDB_->Execute(" ATTACH DATABASE ? AS ? ", { "/data/test/a.db", "a" });
1095     ASSERT_EQ(errCode, E_INVALID_ARGS);
1096     std::tie(errCode, value) = transDB_->Execute(" DETACH DATABASE ?", { "/data/test/a.db" });
1097     ASSERT_EQ(errCode, E_INVALID_ARGS);
1098     std::tie(errCode, value) = transDB_->Execute(" select * from TEST where id == ?", RdbStore::Values{ 100 });
1099     ASSERT_EQ(errCode, E_INVALID_ARGS);
1100 }
1101 
1102 /* *
1103  * @tc.name: QueryByStep_ThreadSafe_001
1104  * @tc.desc: multi-thread use resultSet and closed etc.
1105  * @tc.type: FUNC
1106  */
1107 HWTEST_F(RdbTransDBTest, QueryByStep_ThreadSafe_001, TestSize.Level1)
1108 {
1109     ValuesBucket row = row_;
1110     auto [errCode, rowId] = transDB_->Insert(TABLE_NAME, row);
1111     ASSERT_EQ(errCode, E_OK);
1112     ASSERT_EQ(rowId, 1);
1113     auto resultSet = transDB_->QueryByStep("select * from TEST");
1114     ASSERT_NE(resultSet, nullptr);
1115     errCode = resultSet->GoToNextRow();
1116     ASSERT_EQ(errCode, E_OK);
1117     std::shared_ptr<std::thread> threads[4];
1118     for (int i = 0; i < 4; ++i) {
__anon9b9bc2ae0102() 1119         threads[i] = std::make_shared<std::thread>([resultSet]() {
1120             RowEntity rowEntity;
1121             while (resultSet->GetRow(rowEntity) != E_ALREADY_CLOSED) {
1122             };
1123         });
1124     }
1125     usleep(200);
1126     resultSet->Close();
1127     for (int i = 0; i < 4; ++i) {
1128         if (threads[i] == nullptr) {
1129             continue;
1130         }
1131         threads[i]->join();
1132         threads[i] = nullptr;
1133     }
1134 }
1135 
1136 /* *
1137  * @tc.name: ExecuteForLastInsertRowId_001
1138  * @tc.desc: INSERT OR IGNORE INTO TEST(id, name) VALUES(?,?)
1139  * @tc.type: FUNC
1140  */
1141 HWTEST_F(RdbTransDBTest, ExecuteForLastInsertRowId_001, TestSize.Level1)
1142 {
1143     int64_t rowId = 0;
1144     auto errCode =
1145         transDB_->ExecuteForLastInsertedRowId(rowId, "INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
1146     ASSERT_EQ(errCode, E_OK);
1147     ASSERT_EQ(rowId, 1);
1148     errCode = transDB_->ExecuteForLastInsertedRowId(rowId, "INSERT OR IGNORE INTO TEST(id, name) VALUES (?,?)",
1149         { 100, "xiaoming" });
1150     ASSERT_EQ(errCode, E_OK);
1151     ASSERT_EQ(rowId, -1);
1152     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1153     ASSERT_NE(resultSet, nullptr);
1154     errCode = resultSet->GoToNextRow();
1155     ASSERT_EQ(errCode, E_OK);
1156     RowEntity rowEntity;
1157     errCode = resultSet->GetRow(rowEntity);
1158     ASSERT_EQ(errCode, E_OK);
1159     auto row = rowEntity.Steal();
1160     ASSERT_TRUE(row["id"] == ValueObject(100));
1161     ASSERT_TRUE(row["name"] == ValueObject("xiaohong"));
1162     int32_t count = -1;
1163     errCode = resultSet->GetRowCount(count);
1164     ASSERT_EQ(errCode, E_OK);
1165     ASSERT_EQ(count, 1);
1166 }
1167 
1168 /* *
1169  * @tc.name: ExecuteForChangedRowCount_001
1170  * @tc.desc: UPDATE TEST SET id=?, name=?
1171  * @tc.type: FUNC
1172  */
1173 HWTEST_F(RdbTransDBTest, ExecuteForChangedRowCount_001, TestSize.Level1)
1174 {
1175     auto [errCode, value] = transDB_->Execute("INSERT INTO TEST(id, name) VALUES (?,?)", { 100, "xiaohong" });
1176     ASSERT_EQ(errCode, E_OK);
1177     ASSERT_EQ(value, ValueObject(1));
1178     int64_t changedRow = 0;
1179     errCode = transDB_->ExecuteForChangedRowCount(changedRow, "UPDATE TEST SET id=?, name=?", { 100, "xiaoming" });
1180     ASSERT_EQ(errCode, E_OK);
1181     ASSERT_EQ(changedRow, 1);
1182     auto resultSet = transDB_->QueryByStep("select * from TEST where id == ?", RdbStore::Values{ 100 });
1183     ASSERT_NE(resultSet, nullptr);
1184     errCode = resultSet->GoToNextRow();
1185     ASSERT_EQ(errCode, E_OK);
1186     RowEntity rowEntity;
1187     errCode = resultSet->GetRow(rowEntity);
1188     ASSERT_EQ(errCode, E_OK);
1189     auto row = rowEntity.Steal();
1190     ASSERT_TRUE(row["id"] == ValueObject(100));
1191     ASSERT_TRUE(row["name"] == ValueObject("xiaoming"));
1192     int32_t count = -1;
1193     errCode = resultSet->GetRowCount(count);
1194     ASSERT_EQ(errCode, E_OK);
1195     ASSERT_EQ(count, 1);
1196 }
1197 } // namespace Test
1198