1 /*
2
3 Copyright (c) 2024 Huawei Device Co., Ltd.
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7 http://www.apache.org/licenses/LICENSE-2.0
8 Unless required by applicable law or agreed to in writing, software
9 distributed under the License is distributed on an "AS IS" BASIS,
10 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 See the License for the specific language governing permissions and
12 limitations under the License.
13 */
14 #include <gtest/gtest.h>
15
16 #include <random>
17 #include <string>
18
19 #include "common.h"
20 #include "grd_api_manager.h"
21 #include "rd_utils.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 RdbExecuteRdTest : public testing::TestWithParam<bool> {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35
36 static const std::string databaseName;
37 static std::shared_ptr<RdbStore> store;
38 static const std::string restoreDatabaseName;
39 static const std::string backupDatabaseName;
40 };
41
42 INSTANTIATE_TEST_CASE_P(, RdbExecuteRdTest, testing::Values(false, true));
43
44 const std::string RdbExecuteRdTest::databaseName = RDB_TEST_PATH + "execute_test.db";
45 const std::string RdbExecuteRdTest::restoreDatabaseName = RDB_TEST_PATH + "execute_test_restore.db";
46 const std::string RdbExecuteRdTest::backupDatabaseName = RDB_TEST_PATH + "execute_test_backup.db";
47 std::shared_ptr<RdbStore> RdbExecuteRdTest::store = nullptr;
48
49 class ExecuteTestOpenRdCallback : public RdbOpenCallback {
50 public:
51 int OnCreate(RdbStore &store) override;
52 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
53 };
54
OnCreate(RdbStore & store)55 int ExecuteTestOpenRdCallback::OnCreate(RdbStore &store)
56 {
57 return E_OK;
58 }
59
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)60 int ExecuteTestOpenRdCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
61 {
62 return E_OK;
63 }
64
SetUpTestCase(void)65 void RdbExecuteRdTest::SetUpTestCase(void)
66 {
67 }
68
TearDownTestCase(void)69 void RdbExecuteRdTest::TearDownTestCase(void)
70 {
71 }
72
SetUp(void)73 void RdbExecuteRdTest::SetUp(void)
74 {
75 if (!IsUsingArkData()) {
76 GTEST_SKIP() << "Current testcase is not compatible from current rdb";
77 }
78 int errCode = E_OK;
79 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
80 RdbStoreConfig config(RdbExecuteRdTest::databaseName);
81 config.SetIsVector(true);
82 config.SetEncryptStatus(GetParam());
83 int num = 300;
84 config.SetNcandidates(num);
85 ExecuteTestOpenRdCallback helper;
86 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
87 EXPECT_NE(RdbExecuteRdTest::store, nullptr);
88 EXPECT_EQ(errCode, E_OK);
89 }
90
TearDown(void)91 void RdbExecuteRdTest::TearDown(void)
92 {
93 RdbExecuteRdTest::store = nullptr;
94 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
95 }
96
97 std::random_device g_rd;
98 std::mt19937 g_gen(g_rd());
99 std::uniform_real_distribution<> dis(-1.0, 1.0);
100
101 /**
102 @tc.name: RdbStore_Execute_001
103 @tc.desc: test RdbStore Execute in vector mode
104 @tc.type: FUNC
105 */
106 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_001, TestSize.Level1)
107 {
108 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
109
110 int64_t id = 0;
111 ValuesBucket values;
112 values.PutInt("id", 1);
113 values.PutString("name", std::string("zhangsan"));
114 values.PutInt("age", 18);
115 values.PutDouble("salary", 100.5);
116 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
117
118 values.Clear();
119 values.PutInt("id", 2);
120 values.PutString("name", std::string("lisi"));
121 values.PutInt("age", 19);
122 values.PutDouble("salary", 200.5);
123 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
124
125 values.Clear();
126 values.PutInt("id", 3);
127 values.PutString("name", std::string("wangyjing"));
128 values.PutInt("age", 20);
129 values.PutDouble("salary", 300.5);
130 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
131 std::vector bindArgs = std::vector{ ValueObject(std::string("18")), ValueObject(std ::string("20")) };
132
133 std::string sqlDelNoBind = "DELETE FROM test WHERE age = 19";
134 std::string sqlSelect = "SELECT * FROM test WHERE age = ? OR age = ?";
135 std::string sqlDelete = "DELETE FROM test WHERE age = ? OR age = ?";
136 EXPECT_EQ(store->ExecuteSql(sqlDelete.c_str(), bindArgs), E_NOT_SUPPORT);
137 EXPECT_EQ(store->ExecuteSql(sqlDelNoBind.c_str()), E_NOT_SUPPORT);
138
139 int64_t count = 0;
140 EXPECT_EQ(store->ExecuteAndGetLong(count, "SELECT COUNT() FROM test where age = 19"), E_NOT_SUPPORT);
141 EXPECT_EQ(store->ExecuteAndGetLong(count, "SELECT COUNT() FROM test"), E_NOT_SUPPORT);
142 EXPECT_EQ(store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"), E_NOT_SUPPORT);
143 EXPECT_EQ(store->Insert(id, "test", values), E_NOT_SUPPORT);
144 }
145
146 /**
147 @tc.name: RdbStore_Execute_002
148 @tc.desc: test RdbStore Execute in vector mode
149 @tc.type: FUNC
150 */
151 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_002, TestSize.Level1)
152 {
153 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
154 std::pair<int, uint64_t> res1 = {};
155 std::pair<int, uint64_t> res2 = {};
156 res1 = store->BeginTrans();
157 EXPECT_EQ(res1.first, E_OK);
158 EXPECT_NE(res1.second, 0);
159 res2 = store->BeginTrans();
160 EXPECT_EQ(res2.first, E_OK);
161 EXPECT_NE(res2.second, 0);
162 EXPECT_EQ(store->RollBack(res1.second), E_OK);
163 EXPECT_EQ(store->Commit(res2.second), E_OK);
164 }
165
166 /**
167 @tc.name: RdbStore_Execute_003
168 @tc.desc: test RdbStore Execute in vector mode. Repeatly require trx.
169 @tc.type: FUNC
170 */
171 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_003, TestSize.Level1)
172 {
173 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
174 std::vector<std::pair<int, uint64_t>> results = {};
175 for (uint32_t i = 0; i < 100; i++) { // Get 100 trxs
176 std::pair<int, uint64_t> res = {};
177 res = store->BeginTrans();
178 EXPECT_TRUE((res.first == E_OK) || (res.first == E_DATABASE_BUSY));
179 results.push_back(res);
180 }
181 for (uint32_t i = 0; i < 100; i++) { // Commit 100 trxs
182 if (results[i].first == E_OK) {
183 EXPECT_EQ(store->RollBack(results[i].second), E_OK);
184 }
185 }
186 }
187
188 /**
189 @tc.name: RdbStore_Execute_004
190 @tc.desc: test RdbStore Execute in vector mode
191 @tc.type: FUNC
192 */
193 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_004, TestSize.Level1)
194 {
195 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
196 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
197 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
198 std::string sqlQuery = "SELECT id FROM test order by repr <-> '[1.1, 0.3, 2.2, 6.6, 1.5, 3.1, 0.6, 0.2]' limit 3;";
199
200 std::pair<int32_t, ValueObject> res = {};
201 res = store->Execute(sqlCreateTable.c_str(), {}, 0);
202 EXPECT_EQ(res.first, E_OK);
203
204 std::pair<int, uint64_t> res1 = {};
205 res1 = store->BeginTrans();
206 EXPECT_EQ(res1.first, E_OK);
207 EXPECT_NE(res1.second, 0);
208
209 res = store->Execute(sqlInsert.c_str(), {}, res1.second);
210 EXPECT_EQ(res.first, E_OK);
211 EXPECT_EQ(store->Commit(res1.second), E_OK);
212 res = store->Execute("DROP TABLE test;", {}, 0);
213 EXPECT_EQ(res.first, E_OK);
214 }
215
216 /**
217 @tc.name: RdbStore_Execute_005
218 @tc.desc: test RdbStore Execute in vector mode
219 @tc.type: FUNC
220 */
221 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_005, TestSize.Level1)
222 {
223 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
224 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
225 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
226 std::string sqlQuery = "SELECT id FROM test order by repr <-> '[1.1, 0.3, 2.2, 6.6, 1.5, 3.1, 0.6, 0.2]' limit 3;";
227
228 std::pair<int32_t, ValueObject> res = {};
229 res = store->Execute(sqlCreateTable.c_str(), {});
230 EXPECT_EQ(res.first, E_OK);
231 res = store->Execute(sqlInsert.c_str(), {});
232 EXPECT_EQ(res.first, E_OK);
233 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlQuery.c_str(), std::vector<ValueObject>());
234 EXPECT_NE(resultSet, nullptr);
235 EXPECT_EQ(resultSet->GoToNextRow(), E_OK);
236 std::vector<std::string> colNames = {};
237 resultSet->GetAllColumnNames(colNames);
238 EXPECT_EQ(colNames.size(), 1);
239 int columnIndex = 0;
240 int intVal = 0;
241 resultSet->GetColumnIndex("id", columnIndex);
242 resultSet->GetInt(columnIndex, intVal);
243 EXPECT_EQ(columnIndex, 0);
244 EXPECT_EQ(intVal, 1);
245 EXPECT_EQ(E_OK, resultSet->Close());
246 res = store->Execute("DROP TABLE test;");
247 EXPECT_EQ(E_OK, res.first);
248 }
249
250 /**
251 @tc.name: RdbStore_Execute_006
252 @tc.desc: test RdbStore Execute in vector mode
253 @tc.type: FUNC
254 */
255 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_006, TestSize.Level1)
256 {
257 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
258 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
259 std::string sqlBeginTrans = "begin;";
260
261 std::string dbPath = "/data/test/execute_test1.db";
262 std::string configStr =
263 "{\"pageSize\":8, \"crcCheckEnable\":0, \"redoFlushByTrx\":1, \"bufferPoolSize\":10240,"
264 "\"sharedModeEnable\":1, \"metaInfoBak\":1, \"maxConnNum\":500 }";
265
266 GRD_DB *db2 = nullptr;
267 GRD_DB *db4 = nullptr;
268 EXPECT_EQ(RdUtils::RdDbOpen(dbPath.c_str(), configStr.c_str(),
269 GRD_DB_OPEN_CREATE | GRD_DB_OPEN_IGNORE_DATA_CORRPUPTION, &db2), E_OK);
270 EXPECT_EQ(RdUtils::RdDbOpen(dbPath.c_str(), configStr.c_str(),
271 GRD_DB_OPEN_CREATE | GRD_DB_OPEN_IGNORE_DATA_CORRPUPTION, &db4), E_OK);
272
273 GRD_SqlStmt *stmt = nullptr;
274 EXPECT_EQ(RdUtils::RdSqlPrepare(db2, sqlCreateTable.c_str(), sqlCreateTable.size(), &stmt, nullptr), E_OK);
275 EXPECT_EQ(RdUtils::RdSqlStep(stmt), E_OK);
276 EXPECT_EQ(RdUtils::RdSqlFinalize(stmt), E_OK);
277
278 stmt = nullptr;
279 EXPECT_EQ(RdUtils::RdSqlPrepare(db4, sqlBeginTrans.c_str(), sqlBeginTrans.size(), &stmt, nullptr), E_OK);
280 EXPECT_EQ(RdUtils::RdSqlStep(stmt), E_OK);
281 EXPECT_EQ(RdUtils::RdSqlFinalize(stmt), E_OK);
282
283 stmt = nullptr;
284 EXPECT_EQ(RdUtils::RdSqlPrepare(db4, sqlInsert.c_str(), sqlInsert.size(), &stmt, nullptr), E_OK);
285 EXPECT_EQ(RdUtils::RdSqlStep(stmt), E_OK);
286 EXPECT_EQ(RdUtils::RdSqlFinalize(stmt), E_OK);
287 EXPECT_EQ(RdUtils::RdDbClose(db2, 0), E_OK);
288 EXPECT_EQ(RdUtils::RdDbClose(db4, 0), E_OK);
289 }
290
GetRandVector(uint32_t maxElementNum,uint16_t dim)291 std::string GetRandVector(uint32_t maxElementNum, uint16_t dim)
292 {
293 if (maxElementNum == 0) {
294 return "";
295 }
296 unsigned int randomNumberSeed = time(nullptr);
297 std::string res = "[";
298 for (uint16_t i = 0; i < dim; i++) {
299 uint32_t intPart = (rand_r(&randomNumberSeed) % maxElementNum);
300 intPart += 1;
301 uint32_t tenths = (rand_r(&randomNumberSeed) % 10); // 10是用来限制小数点后的数字不能超过10
302 res += std::to_string(intPart);
303 res += ".";
304 res += std::to_string(tenths);
305 res += ", ";
306 }
307 res.pop_back();
308 res.pop_back();
309 res += "]";
310 return res;
311 }
312
313 constexpr uint32_t MAX_INT_PART = 10;
314 constexpr uint16_t LARGE_ANN_INDEX_DIM = 8;
CreateIdxAndSelect(std::string & sqlSelect)315 std::shared_ptr<ResultSet> CreateIdxAndSelect(std::string &sqlSelect)
316 {
317 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
318
319 std::string sqlCreateTable =
320 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
321 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
322
323 std::pair<int32_t, ValueObject> res = {};
324 res = store->Execute(sqlCreateTable.c_str(), {});
325 EXPECT_EQ(res.first, E_OK);
326 res = store->Execute(sqlCreateIndex.c_str(), {});
327 EXPECT_EQ(res.first, E_OK);
328 for (uint16_t i = 0; i < 10; i++) { // iterate 10 times to insert 10 data
329 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
330 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
331 res = store->Execute(sqlInsert.c_str(), {});
332 EXPECT_EQ(res.first, E_OK);
333 }
334 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
335 EXPECT_NE(resultSet, nullptr);
336
337 bool isStarted = false;
338 bool isAtFirstRow = false;
339 EXPECT_EQ(E_OK, resultSet->IsStarted(isStarted));
340 EXPECT_EQ(E_OK, resultSet->IsAtFirstRow(isAtFirstRow));
341 EXPECT_EQ(false, isStarted);
342 EXPECT_EQ(false, isAtFirstRow);
343
344 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
345 EXPECT_EQ(E_OK, resultSet->IsStarted(isStarted));
346 EXPECT_EQ(E_OK, resultSet->IsAtFirstRow(isAtFirstRow));
347 EXPECT_EQ(true, isStarted);
348 EXPECT_EQ(true, isAtFirstRow);
349
350 std::vector<std::string> colNames = {};
351 resultSet->GetAllColumnNames(colNames);
352 EXPECT_EQ(colNames.size(), 2); // Expect 2 columns
353 return resultSet;
354 }
355
356 /**
357 @tc.name: RdbStore_Execute_007
358 @tc.desc: test RdbStore Execute in vector mode
359 @tc.type: FUNC
360 */
361 constexpr uint16_t SELECT_RES_NUM = 3;
362 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_007, TestSize.Level1)
363 {
364 std::string sqlSelect = "SELECT * FROM test ORDER BY repr <-> '" +
365 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "' LIMIT " +
366 std::to_string(SELECT_RES_NUM) + ";";
367 std::shared_ptr<ResultSet> resultSet = CreateIdxAndSelect(sqlSelect);
368 int columnIndex = 0;
369 size_t vectSize = 0;
370 ValueObject::FloatVector vecs = {};
371 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
372 EXPECT_EQ(columnIndex, 1);
373
374 ColumnType colType = ColumnType::TYPE_NULL;
375 EXPECT_EQ(E_OK, resultSet->GetColumnType(columnIndex, colType));
376 EXPECT_EQ(ColumnType::TYPE_FLOAT32_ARRAY, colType);
377
378 EXPECT_EQ(E_OK, resultSet->GetFloat32Array(columnIndex, vecs));
379 EXPECT_EQ(E_OK, resultSet->GetSize(columnIndex, vectSize));
380 EXPECT_EQ(vecs.size(), LARGE_ANN_INDEX_DIM);
381 EXPECT_EQ(sizeof(float) * LARGE_ANN_INDEX_DIM, vectSize);
382
383 int idVal = 0;
384 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("id", columnIndex));
385 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, idVal));
386
387 int ret = E_OK;
388 int resCnt = 0;
389 vecs.clear();
390 while ((ret = resultSet->GoToNextRow() == E_OK)) {
391 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
392 EXPECT_EQ(1, columnIndex); // 1是向量的列
393
394 resultSet->GetColumnType(columnIndex, colType);
395 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT32_ARRAY);
396
397 EXPECT_EQ(E_COLUMN_OUT_RANGE, resultSet->GetColumnType(100, colType)); // 100是一个不存在的col, 所以预期返回NULL
398
399 EXPECT_EQ(E_OK, resultSet->GetFloat32Array(columnIndex, vecs));
400 EXPECT_EQ(E_OK, resultSet->GetSize(columnIndex, vectSize));
401 EXPECT_EQ(vecs.size(), LARGE_ANN_INDEX_DIM);
402 EXPECT_EQ(sizeof(float) * LARGE_ANN_INDEX_DIM, vectSize);
403 resCnt++;
404 }
405 EXPECT_EQ(SELECT_RES_NUM - 1, resCnt);
406 EXPECT_EQ(E_OK, resultSet->Close());
407 std::pair<int32_t, ValueObject> res = RdbExecuteRdTest::store->Execute("DROP TABLE test;");
408 EXPECT_EQ(E_OK, res.first);
409 }
410
411 /**
412 @tc.name: RdbStore_Execute_008
413 @tc.desc: test RdbStore Execute in vector mode
414 @tc.type: FUNC
415 */
416 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_008, TestSize.Level1)
417 {
418 std::string sqlSelect = "SELECT * FROM test;";
419 std::shared_ptr<ResultSet> resultSet = CreateIdxAndSelect(sqlSelect);
420 int columnIndex = 0;
421 size_t vectSize = 0;
422 ValueObject::FloatVector vecs = {};
423 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
424 EXPECT_EQ(columnIndex, 1);
425
426 ColumnType colType = ColumnType::TYPE_NULL;
427 EXPECT_EQ(E_OK, resultSet->GetColumnType(columnIndex, colType));
428 EXPECT_EQ(ColumnType::TYPE_FLOAT32_ARRAY, colType);
429
430 int idVal = 0;
431 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("id", columnIndex));
432 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, idVal));
433
434 int ret = E_OK;
435 int resCnt = 1;
436 vecs.clear();
437 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
438 while ((ret = resultSet->GoToNextRow() == E_OK)) {
439 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
440 EXPECT_EQ(1, columnIndex); // 1是向量的列， columnIndex期望是1
441
442 resultSet->GetColumnType(columnIndex, colType);
443 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT32_ARRAY);
444
445 EXPECT_EQ(E_OK, resultSet->GetFloat32Array(columnIndex, vecs));
446 EXPECT_EQ(E_OK, resultSet->GetSize(columnIndex, vectSize));
447 EXPECT_EQ(vecs.size(), LARGE_ANN_INDEX_DIM);
448 EXPECT_EQ(sizeof(float) * LARGE_ANN_INDEX_DIM, vectSize);
449 resCnt++;
450 }
451 EXPECT_EQ(10, resCnt); // 期待resCnt是10
452 EXPECT_EQ(E_OK, resultSet->Close());
453 std::pair<int32_t, ValueObject> res = RdbExecuteRdTest::store->Execute("DROP TABLE test;");
454 EXPECT_EQ(E_OK, res.first);
455 }
456
457 /**
458 @tc.name: RdbStore_Execute_009
459 @tc.desc: test RdbStore Execute in vector mode
460 @tc.type: FUNC
461 */
462 constexpr uint32_t EXPEC_INSERT_CNT_FOR = 10;
463 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_009, TestSize.Level1)
464 {
465 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
466
467 std::string sqlCreateTable =
468 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
469 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
470 std::string sqlSelect = "SELECT * FROM test;";
471
472 std::pair<int32_t, ValueObject> res = {};
473 res = store->Execute(sqlCreateTable.c_str(), {});
474 EXPECT_EQ(res.first, E_OK);
475
476 std::pair<int32_t, int64_t> trx = {};
477 trx = store->BeginTrans();
478 EXPECT_EQ(trx.first, E_OK);
479
480 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
481 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
482 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
483 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
484 EXPECT_EQ(res.first, E_OK);
485 }
486 EXPECT_EQ(E_OK, store->Commit(trx.second));
487
488 res = store->Execute(sqlCreateIndex.c_str(), {});
489 EXPECT_EQ(res.first, E_OK);
490
491 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
492 EXPECT_NE(resultSet, nullptr);
493
494 int32_t resCnt = 0;
495 while (resultSet->GoToNextRow() == E_OK) {
496 resCnt++;
497 }
498 EXPECT_EQ(EXPEC_INSERT_CNT_FOR, resCnt);
499 }
500
501 /**
502 @tc.name: RdbStore_Execute_010
503 @tc.desc: test RdbStore Execute in vector mode
504 @tc.type: FUNC
505 */
506 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_010, TestSize.Level1)
507 {
508 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
509
510 std::string sqlCreateTable =
511 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
512 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
513 std::string sqlSelect = "SELECT * FROM test;";
514
515 std::pair<int32_t, ValueObject> res = {};
516 res = store->Execute(sqlCreateTable.c_str(), {});
517 EXPECT_EQ(res.first, E_OK);
518
519 for (uint16_t i = 0; i < 10; i++) {
520 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
521 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
522 res = store->Execute(sqlInsert.c_str(), {}, 0);
523 EXPECT_EQ(res.first, E_OK);
524 }
525
526 std::pair<int32_t, int64_t> trx = {};
527 trx = store->BeginTrans();
528 EXPECT_EQ(trx.first, E_OK);
529 EXPECT_NE(trx.second, 0);
530
531 for (uint16_t i = 0; i < 10; i++) {
532 std::string sqlDelete = "DELETE FROM test WHERE id = 1000000" + std::to_string(i) + ";";
533 res = store->Execute(sqlDelete.c_str(), {}, trx.second);
534 EXPECT_EQ(res.first, E_OK);
535 }
536
537 EXPECT_EQ(E_OK, store->Commit(trx.second));
538
539 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
540 EXPECT_NE(resultSet, nullptr);
541 EXPECT_EQ(E_ROW_OUT_RANGE, resultSet->GoToNextRow());
542 }
543
544 /**
545 @tc.name: RdbStore_Execute_011
546 @tc.desc: test RdbStore Execute in vector mode
547 @tc.type: FUNC
548 */
549 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_011, TestSize.Level1)
550 {
551 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
552
553 std::string sqlCreateTable = "CREATE TABLE test(id int primary key, day int, repr floatvector(" +
554 std::to_string(LARGE_ANN_INDEX_DIM) + "));";
555 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
556 std::string sqlSelect = "SELECT * FROM test;";
557
558 std::pair<int32_t, ValueObject> res = {};
559 res = store->Execute(sqlCreateTable.c_str(), {});
560 EXPECT_EQ(res.first, E_OK);
561
562 for (uint16_t i = 0; i < 10; i++) {
563 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", 0, '" +
564 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
565 res = store->Execute(sqlInsert.c_str(), {}, 0);
566 EXPECT_EQ(res.first, E_OK);
567 }
568
569 std::pair<int32_t, int64_t> trx = {};
570 trx = store->BeginTrans();
571 EXPECT_EQ(trx.first, E_OK);
572 EXPECT_NE(trx.second, 0);
573
574 for (uint16_t i = 0; i < 10; i++) {
575 std::string sqlDelete = "UPDATE test SET day = 1 WHERE id = 1000000" + std::to_string(i) + ";";
576 res = store->Execute(sqlDelete.c_str(), {}, trx.second);
577 EXPECT_EQ(res.first, E_OK);
578 }
579
580 EXPECT_EQ(E_OK, store->Commit(trx.second));
581 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
582 EXPECT_NE(resultSet, nullptr);
583
584 uint32_t resCnt = 0;
585 int64_t intVal = 0;
586 int columnIndex = 0;
587 ColumnType colType = ColumnType::TYPE_NULL;
588
589 while (resultSet->GoToNextRow() == E_OK) {
590 std::vector<std::string> colNames = {};
591 resultSet->GetAllColumnNames(colNames);
592 EXPECT_STREQ("id", colNames[0].c_str());
593 EXPECT_STREQ("day", colNames[1].c_str());
594 EXPECT_STREQ("repr", colNames[2].c_str());
595
596 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("day", columnIndex));
597 EXPECT_EQ(1, columnIndex); // 1是day的列
598
599 EXPECT_EQ(E_OK, resultSet->GetColumnType(columnIndex, colType));
600 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
601
602 EXPECT_EQ(
603 E_COLUMN_OUT_RANGE, resultSet->GetColumnType(100, colType)); // 100是一个不存在的col, 所以预期返回错误码
604 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER); // 值不会被更新
605
606 EXPECT_EQ(E_OK, resultSet->GetLong(columnIndex, intVal));
607 EXPECT_EQ(1, intVal);
608
609 resCnt++;
610 }
611 }
612
613 /**
614 @tc.name: RdbStore_Execute_012
615 @tc.desc: test RdbStore Execute in vector mode
616 @tc.type: FUNC
617 */
618 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_012, TestSize.Level1)
619 {
620 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
621
622 std::string sqlCreateTable =
623 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
624 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
625 std::string sqlSelect = "SELECT * FROM test;";
626
627 std::pair<int32_t, ValueObject> res = {};
628 res = store->Execute(sqlCreateTable.c_str(), {});
629 EXPECT_EQ(res.first, E_OK);
630
631 std::pair<int32_t, int64_t> trx = {};
632 trx = store->BeginTrans();
633 EXPECT_EQ(trx.first, E_OK);
634
635 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
636 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
637 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
638 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
639 EXPECT_EQ(res.first, E_OK);
640 }
641 EXPECT_EQ(E_OK, store->RollBack(trx.second));
642
643 res = store->Execute(sqlCreateIndex.c_str(), {});
644 EXPECT_EQ(res.first, E_OK);
645
646 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
647 EXPECT_NE(resultSet, nullptr);
648
649 int32_t resCnt = 0;
650 while (resultSet->GoToNextRow() == E_OK) {
651 resCnt++;
652 }
653 EXPECT_EQ(0, resCnt);
654 }
655
656 /**
657 @tc.name: RdbStore_Execute_013
658 @tc.desc: test RdbStore Execute in vector mode
659 @tc.type: FUNC
660 */
661 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_013, TestSize.Level1)
662 {
663 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
664
665 std::string sqlCreateTable =
666 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
667 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
668 std::string sqlSelect = "SELECT * FROM test;";
669
670 std::pair<int32_t, ValueObject> res = {};
671 res = store->Execute(sqlCreateTable.c_str(), {});
672 EXPECT_EQ(res.first, E_OK);
673
674 std::pair<int32_t, int64_t> trx = {};
675 trx = store->BeginTrans();
676 EXPECT_EQ(trx.first, E_OK);
677
678 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
679 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
680 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
681 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
682 EXPECT_EQ(res.first, E_OK);
683 }
684 EXPECT_EQ(E_OK, store->RollBack(trx.second));
685
686 res = store->Execute(sqlCreateIndex.c_str(), {});
687 EXPECT_EQ(res.first, E_OK);
688
689 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
690 EXPECT_NE(resultSet, nullptr);
691
692 int32_t resCnt = 0;
693 while (resultSet->GoToNextRow() == E_OK) {
694 resCnt++;
695 }
696 EXPECT_EQ(0, resCnt);
697 }
698
699 /**
700 @tc.name: RdbStore_Execute_014
701 @tc.desc: test RdbStore Execute update in transaction
702 @tc.type: FUNC
703 */
704 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_014, TestSize.Level1)
705 {
706 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
707
708 std::string sqlCreateTable = "CREATE TABLE test(id int primary key, age int, repr floatvector(" +
709 std::to_string(LARGE_ANN_INDEX_DIM) + "));";
710 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
711 std::string sqlSelect = "SELECT * FROM test;";
712
713 std::pair<int32_t, ValueObject> res = {};
714 res = store->Execute(sqlCreateTable.c_str(), {});
715 EXPECT_EQ(res.first, E_OK);
716
717 for (uint16_t i = 0; i < 10; i++) {
718 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", " + std::to_string(i) +
719 ", '" + GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
720 res = store->Execute(sqlInsert.c_str(), {}, 0);
721 EXPECT_EQ(res.first, E_OK);
722 }
723
724 std::pair<int32_t, int64_t> trx = {};
725 trx = store->BeginTrans();
726 EXPECT_EQ(trx.first, E_OK);
727 EXPECT_NE(trx.second, 0);
728
729 for (uint16_t i = 0; i < 10; i++) {
730 std::string sqlUpdate = "UPDATE test SET age = 1 WHERE id = 1000000" + std::to_string(i) + ";";
731 res = store->Execute(sqlUpdate.c_str(), {}, trx.second);
732 EXPECT_EQ(res.first, E_OK);
733 }
734
735 EXPECT_EQ(E_OK, store->Commit(trx.second));
736 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
737 int columnIndex = 0;
738 while (resultSet->GoToNextRow() == E_OK) {
739 std::vector<std::string> colNames = {};
740 resultSet->GetAllColumnNames(colNames);
741 EXPECT_STREQ("id", colNames[0].c_str());
742 EXPECT_STREQ("age", colNames[1].c_str());
743 EXPECT_STREQ("repr", colNames[2].c_str());
744
745 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("age", columnIndex));
746 EXPECT_EQ(1, columnIndex); // 1是age的列
747 int result;
748 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, result));
749 EXPECT_EQ(result, 1);
750 }
751 }
752
753 /**
754 @tc.name: RdbStore_Execute_014
755 @tc.desc: test RdbStore Execute Repeatly Get Transaction
756 @tc.type: FUNC
757 */
758 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_015, TestSize.Level1)
759 {
760 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
761
762 std::string sqlCreateTable = "CREATE TABLE test2 (id INTEGER PRIMARY KEY, repr INTEGER);";
763 std::string sqlSelect = "SELECT * FROM test2;";
764
765 std::pair<int32_t, ValueObject> res = {};
766 res = store->Execute(sqlCreateTable.c_str(), {});
767 EXPECT_EQ(res.first, E_OK);
768
769 for (uint32_t i = 0; i < 10; i++) {
770 std::pair<int32_t, int64_t> trx = {};
771 trx = store->BeginTrans();
772 EXPECT_EQ(trx.first, E_OK);
773 std::string sqlInsert = "INSERT INTO test2 VALUES(" + std::to_string(i) + ", 1);";
774 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
775 EXPECT_EQ(res.first, E_OK);
776 EXPECT_EQ(E_OK, store->Commit(trx.second));
777 }
778
779 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
780 EXPECT_NE(resultSet, nullptr);
781
782 int32_t resCnt = 0;
783 while (resultSet->GoToNextRow() == E_OK) {
784 int rowIdx = 0;
785 resultSet->GetRowIndex(rowIdx);
786 EXPECT_EQ(resCnt, rowIdx);
787 resCnt++;
788 }
789 EXPECT_EQ(10, resCnt);
790 }
791
792 /**
793 @tc.name: RdbStore_Execute_016
794 @tc.desc: test RdbStore Execute Repeatly Get Transaction
795 @tc.type: FUNC
796 */
797 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_016, TestSize.Level1)
798 {
799 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
800 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test1 (docId Text, str Text, repr floatvector(4));";
801 std::string sqlCreateIdx = "CREATE INDEX test_idx ON test1 USING GSIVFFLAT(repr L2);";
802 std::string sqlSelect = "SELECT * FROM test1 ORDER BY repr <-> '[1.0, 2.0, 3.0, 4.0]' LIMIT 2;";
803
804 std::pair<int32_t, ValueObject> res = store->Execute(sqlCreateTable.c_str(), {});
805 EXPECT_EQ(res.first, E_OK);
806 res = store->Execute(sqlCreateIdx.c_str(), {});
807 EXPECT_EQ(res.first, E_OK);
808
809 std::vector<std::vector<float>> vectorSamples = { { 1.0, 2.0, 3.0, 4.0 }, { 10, 20, 30, 40 },
810 { 100, 200, 300, 400 } };
811
812 for (uint32_t i = 0; i < vectorSamples.size(); i++) {
813 std::pair<int32_t, int64_t> trx = {};
814 trx = store->BeginTrans();
815 EXPECT_EQ(trx.first, E_OK);
816 std::string sqlInsert = "insert into test1 values('" + std::to_string(i) + "', ?, ?);";
817 ValueObject floatObj = ValueObject(vectorSamples[i]);
818 ValueObject::FloatVector vector = {};
819 EXPECT_EQ(floatObj.GetVecs(vector), E_OK);
820 EXPECT_EQ(vectorSamples[i].size(), vector.size());
821 for (size_t j = 0; j < vector.size(); j++) {
822 EXPECT_FLOAT_EQ(vectorSamples[i][j], vector[j]);
823 }
824
825 res = store->Execute(sqlInsert.c_str(), { ValueObject(std::string("textVal")), floatObj }, trx.second);
826 EXPECT_EQ(res.first, E_OK);
827 EXPECT_EQ(E_OK, store->Commit(trx.second));
828 }
829
830 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
831 EXPECT_NE(resultSet, nullptr);
832
833 int32_t resCnt = 0;
834 while (resultSet->GoToNextRow() == E_OK) {
835 std::string primaryStrVal = "";
836 std::string textStrVal = "";
837 ValueObject::FloatVector floatVector = {};
838 resultSet->GetString(0, primaryStrVal); // 0 is the index of primary String column in select projection
839 resultSet->GetString(1, textStrVal); // 1 is the index of TEXT column in select projection
840 resultSet->GetFloat32Array(2, floatVector); // 2 is the index of vector column in select projection
841 EXPECT_STREQ(std::to_string(resCnt).c_str(), primaryStrVal.c_str());
842 EXPECT_STREQ("textVal", textStrVal.c_str());
843 EXPECT_EQ(vectorSamples[resCnt].size(), floatVector.size());
844 for (size_t i = 0; i < floatVector.size(); i++) {
845 EXPECT_FLOAT_EQ(vectorSamples[resCnt][i], floatVector[i]);
846 }
847 resCnt++;
848 }
849 EXPECT_EQ(2, resCnt); // Expect 2 result due to limit 2
850 }
851
852 /**
853 @tc.name: RdbStore_Execute_017
854 @tc.desc: test RdbStore Execute Getting or Setting version
855 @tc.type: FUNC
856 */
857 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_017, TestSize.Level1)
858 {
859 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
860 int versionToGet = 0;
861 int versionToSet = 1;
862 EXPECT_EQ(E_OK, store->SetVersion(versionToSet));
863 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
864 EXPECT_EQ(versionToGet, versionToSet);
865
866 std::string sqlPragmaSetVersion = "PRAGMA user_version = 3";
867 std::pair<int32_t, ValueObject> res = {};
868 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
869 EXPECT_EQ(res.first, E_OK);
870 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
871 EXPECT_EQ(versionToGet, 3); // 3 is set by sql
872
873 sqlPragmaSetVersion = "PRAGMA user_version = 4;";
874 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
875 EXPECT_EQ(res.first, E_OK);
876 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
877 EXPECT_EQ(versionToGet, 4); // 4 is set by sql
878
879 sqlPragmaSetVersion = "PRAGMA user_version = 35678";
880 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
881 EXPECT_EQ(res.first, E_OK);
882 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
883 EXPECT_EQ(versionToGet, 35678); // 35678 is set by sql
884
885 sqlPragmaSetVersion = "PRAGMA user_version = asdfds";
886 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
887 EXPECT_EQ(res.first, E_INCORRECT_SQL);
888
889 sqlPragmaSetVersion = "PRAGMA user_version = ;";
890 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
891 EXPECT_EQ(res.first, E_INCORRECT_SQL);
892
893 sqlPragmaSetVersion = "PRAGMA user_version = 456 ";
894 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
895 EXPECT_EQ(res.first, E_OK);
896 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
897 EXPECT_EQ(versionToGet, 456); // 456 is set by sql
898
899 sqlPragmaSetVersion = "PRAGMA user_version = 456 1231 ";
900 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
901 EXPECT_EQ(res.first, E_INCORRECT_SQL);
902
903 sqlPragmaSetVersion = "PRAGMA user_version = 456 1asdf231 ";
904 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
905 EXPECT_EQ(res.first, E_INCORRECT_SQL);
906 }
907
908 /**
909 @tc.name: RdbStore_Execute_018
910 @tc.desc: test RdbStore create encrypted db from non-encrypted db
911 @tc.type: FUNC
912 */
913 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_018, TestSize.Level1)
914 {
915 RdbExecuteRdTest::store = nullptr;
916 bool isOriginDbEncrypt = GetParam();
917
918 RdbStoreConfig config(RdbExecuteRdTest::databaseName);
919 config.SetIsVector(true);
920 config.SetEncryptStatus(!isOriginDbEncrypt);
921 ExecuteTestOpenRdCallback helper;
922 int errCode = E_OK;
923 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
924 // open encrypted-db in un-encrypted mode is not allowed
925 // open un-encrypted db in encrypted-db is allowed
926 EXPECT_TRUE((isOriginDbEncrypt && RdbExecuteRdTest::store == nullptr) ||
927 (!isOriginDbEncrypt && RdbExecuteRdTest::store != nullptr));
928 if (!isOriginDbEncrypt) {
929 RdbExecuteRdTest::store = nullptr;
930 config.SetEncryptStatus(false); // open encrypted-db update from un-encrypt in un-encrypted mode is not allowed
931 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
932 EXPECT_EQ(store, nullptr);
933 }
934 }
935
936 /**
937 * @tc.name: RdbStore_Execute_019
938 * @tc.desc: test RdbStore Execute in vector mode
939 * @tc.type: FUNC
940 */
941 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_019, TestSize.Level1)
942 {
943 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
944 const char *sqlCreateTable = "CREATE TABLE vecTable(inode int primary key, embedding floatvector(4));";
945 auto res = store->Execute(sqlCreateTable);
946 EXPECT_EQ(E_OK, res.first);
947
948 const char *sqlCreateIndex = "CREATE INDEX diskann_cos_idx ON vecTable USING GSDISKANN(embedding COSINE);";
949 res = store->Execute(sqlCreateIndex);
950 EXPECT_EQ(E_OK, res.first);
951
952 std::string sqlInsert = "INSERT INTO vecTable VALUES(1, '[1,2,-3,4]'), (2, '[2,2,-3,4]'), (3, '[3,2,3,4]'), (4, "
953 "'[4,2,3,4]'), (5, '[5,2,-3,4]')";
954 for (int i = 6; i <= 1000; i++) {
955 std::string tmpStr = ", (" + std::to_string(i) + ", '[" + std::to_string(dis(g_gen)) + "," +
956 std::to_string(dis(g_gen)) + "," + std::to_string(dis(g_gen)) + "," +
957 std::to_string(dis(g_gen)) + "]')";
958 sqlInsert.append(tmpStr);
959 }
960 sqlInsert.append(";");
961 res = store->Execute(sqlInsert);
962 EXPECT_EQ(E_OK, res.first);
963
964 const char *sqlSelect = "SELECT inode, embedding, embedding<=>'[1,1,1,1]' AS score FROM vecTable ORDER BY "
965 "embedding<=>'[1,1,1,1]' LIMIT 501;";
966 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect, std::vector<ValueObject>());
967 EXPECT_NE(resultSet, nullptr);
968 int count = 0;
969 resultSet->GetRowCount(count);
970 EXPECT_EQ(count, 299);
971 const char *sqlDelete = "DELETE FROM vecTable";
972 res = store->Execute(sqlDelete);
973 EXPECT_EQ(E_OK, res.first);
974 }
975
976 /* *
977 * @tc.name: Rdb_BackupRestoreTest_001
978 * @tc.desc: backup and restore
979 * @tc.type: FUNC
980 */
981 HWTEST_P(RdbExecuteRdTest, Rdb_BackupRestoreTest_001, TestSize.Level2)
982 {
983 //create new db instance
984 int errCode = E_OK;
985 RdbStoreConfig config(RdbExecuteRdTest::restoreDatabaseName);
986 config.SetIsVector(true);
987 config.SetSecurityLevel(SecurityLevel::S4);
988 config.SetEncryptStatus(GetParam());
989 if (GetParam()) { // check if encrypt
990 config.SetHaMode(HAMode::MAIN_REPLICA);
991 }
992 config.SetAllowRebuild(true);
993 ExecuteTestOpenRdCallback helper;
994 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
995 EXPECT_EQ(errCode, E_OK);
996 EXPECT_NE(store, nullptr);
997
998 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
999 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
1000 std::string sqlQuery = "SELECT id FROM test order by repr <-> '[1.1, 0.3, 2.2, 6.6, 1.5, 3.1, 0.6, 0.2]' limit 3;";
1001
1002 std::pair<int32_t, ValueObject> res = {};
1003 res = store->Execute(sqlCreateTable.c_str(), {});
1004 EXPECT_EQ(res.first, E_OK);
1005 res = store->Execute(sqlInsert.c_str(), {});
1006 EXPECT_EQ(res.first, E_OK);
1007
1008 std::vector<uint8_t> encryptKey;
1009 if (GetParam()) {
1010 encryptKey = config.GetEncryptKey();
1011 }
1012
1013 int ret = store->Backup(RdbExecuteRdTest::backupDatabaseName, encryptKey);
1014 EXPECT_EQ(ret, E_OK);
1015
1016 res = store->Execute("delete from test where id = 1;");
1017 EXPECT_EQ(E_OK, res.first);
1018
1019 ret = store->Restore(RdbExecuteRdTest::backupDatabaseName, encryptKey);
1020 EXPECT_EQ(ret, E_OK);
1021
1022 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlQuery.c_str(), std::vector<ValueObject>());
1023
1024 //check the result
1025 EXPECT_NE(resultSet, nullptr);
1026 EXPECT_EQ(resultSet->GoToNextRow(), E_OK);
1027 std::vector<std::string> colNames = {};
1028 resultSet->GetAllColumnNames(colNames);
1029 EXPECT_EQ(colNames.size(), 1);
1030 int columnIndex = 0;
1031 int intVal = 0;
1032 resultSet->GetColumnIndex("id", columnIndex);
1033 resultSet->GetInt(columnIndex, intVal);
1034 EXPECT_EQ(columnIndex, 0);
1035 EXPECT_EQ(intVal, 1);
1036 EXPECT_EQ(E_OK, resultSet->Close());
1037 res = store->Execute("DROP TABLE test;");
1038 EXPECT_EQ(E_OK, res.first);
1039
1040 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::restoreDatabaseName);
1041 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::backupDatabaseName);
1042 }
1043
1044 /* *
1045 * @tc.name: Rdb_IsUsingArkDataTest_001
1046 * @tc.desc: IsUsingArkData function test
1047 * @tc.type: FUNC
1048 */
1049 HWTEST_P(RdbExecuteRdTest, Rdb_IsUsingArkDataTest_001, TestSize.Level2)
1050 {
1051 EXPECT_EQ(OHOS::NativeRdb::RdbHelper::IsSupportArkDataDb(), true);
1052 }