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 <string>
17
18 #include "common.h"
19 #include "grd_api_manager.h"
20 #include "rd_utils.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27
28 class RdbExecuteRdTest : public testing::TestWithParam<bool> {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34
35 static const std::string databaseName;
36 static std::shared_ptr<RdbStore> store;
37 static const std::string restoreDatabaseName;
38 static const std::string backupDatabaseName;
39 };
40
41 INSTANTIATE_TEST_CASE_P(, RdbExecuteRdTest, testing::Values(false, true));
42
43 const std::string RdbExecuteRdTest::databaseName = RDB_TEST_PATH + "execute_test.db";
44 const std::string RdbExecuteRdTest::restoreDatabaseName = RDB_TEST_PATH + "execute_test_restore.db";
45 const std::string RdbExecuteRdTest::backupDatabaseName = RDB_TEST_PATH + "execute_test_backup.db";
46 std::shared_ptr<RdbStore> RdbExecuteRdTest::store = nullptr;
47 const bool IS_TESTING_PERFORMANCE = false;
48 const int BATCH_TOTAL_SIZE = IS_TESTING_PERFORMANCE ? 12000 : 120;
49 const int BATCH_SIZE = IS_TESTING_PERFORMANCE ? 100 : 10;
50 const int MAX_VARIABLE_NUM = 32766;
51
52 class ExecuteTestOpenRdCallback : public RdbOpenCallback {
53 public:
54 int OnCreate(RdbStore &store) override;
55 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
56 };
57
OnCreate(RdbStore & store)58 int ExecuteTestOpenRdCallback::OnCreate(RdbStore &store)
59 {
60 return E_OK;
61 }
62
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)63 int ExecuteTestOpenRdCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
64 {
65 return E_OK;
66 }
67
SetUpTestCase(void)68 void RdbExecuteRdTest::SetUpTestCase(void)
69 {
70 }
71
TearDownTestCase(void)72 void RdbExecuteRdTest::TearDownTestCase(void)
73 {
74 }
75
SetUp(void)76 void RdbExecuteRdTest::SetUp(void)
77 {
78 if (!IsUsingArkData()) {
79 GTEST_SKIP() << "Current testcase is not compatible from current rdb";
80 }
81 int errCode = E_OK;
82 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
83 RdbStoreConfig config(RdbExecuteRdTest::databaseName);
84 config.SetIsVector(true);
85 config.SetEncryptStatus(GetParam());
86 ExecuteTestOpenRdCallback helper;
87 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
88 EXPECT_NE(RdbExecuteRdTest::store, nullptr);
89 EXPECT_EQ(errCode, E_OK);
90 }
91
TearDown(void)92 void RdbExecuteRdTest::TearDown(void)
93 {
94 RdbExecuteRdTest::store = nullptr;
95 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
96 }
97
98 /**
99 @tc.name: RdbStore_Execute_001
100 @tc.desc: test RdbStore Execute in vector mode
101 @tc.type: FUNC
102 */
103 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_001, TestSize.Level1)
104 {
105 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
106
107 int64_t id = 0;
108 ValuesBucket values;
109 values.PutInt("id", 1);
110 values.PutString("name", std::string("zhangsan"));
111 values.PutInt("age", 18);
112 values.PutDouble("salary", 100.5);
113 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
114
115 values.Clear();
116 values.PutInt("id", 2);
117 values.PutString("name", std::string("lisi"));
118 values.PutInt("age", 19);
119 values.PutDouble("salary", 200.5);
120 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
121
122 values.Clear();
123 values.PutInt("id", 3);
124 values.PutString("name", std::string("wangyjing"));
125 values.PutInt("age", 20);
126 values.PutDouble("salary", 300.5);
127 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
128 std::vector bindArgs = std::vector{ ValueObject(std::string("18")), ValueObject(std ::string("20")) };
129
130 std::string sqlDelNoBind = "DELETE FROM test WHERE age = 19";
131 std::string sqlSelect = "SELECT * FROM test WHERE age = ? OR age = ?";
132 std::string sqlDelete = "DELETE FROM test WHERE age = ? OR age = ?";
133 EXPECT_EQ(store->ExecuteSql(sqlDelete.c_str(), bindArgs), E_NOT_SUPPORT);
134 EXPECT_EQ(store->ExecuteSql(sqlDelNoBind.c_str()), E_NOT_SUPPORT);
135
136 int64_t count = 0;
137 EXPECT_EQ(store->ExecuteAndGetLong(count, "SELECT COUNT() FROM test where age = 19"), E_NOT_SUPPORT);
138 EXPECT_EQ(store->ExecuteAndGetLong(count, "SELECT COUNT() FROM test"), E_NOT_SUPPORT);
139 EXPECT_EQ(store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"), E_NOT_SUPPORT);
140 EXPECT_EQ(store->Insert(id, "test", values), E_NOT_SUPPORT);
141 }
142
143 /**
144 @tc.name: RdbStore_Execute_002
145 @tc.desc: test RdbStore Execute in vector mode
146 @tc.type: FUNC
147 */
148 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_002, TestSize.Level1)
149 {
150 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
151 std::pair<int, uint64_t> res1 = {};
152 std::pair<int, uint64_t> res2 = {};
153 res1 = store->BeginTrans();
154 EXPECT_EQ(res1.first, E_OK);
155 EXPECT_NE(res1.second, 0);
156 res2 = store->BeginTrans();
157 EXPECT_EQ(res2.first, E_OK);
158 EXPECT_NE(res2.second, 0);
159 EXPECT_EQ(store->RollBack(res1.second), E_OK);
160 EXPECT_EQ(store->Commit(res2.second), E_OK);
161 }
162
163 /**
164 @tc.name: RdbStore_Execute_003
165 @tc.desc: test RdbStore Execute in vector mode. Repeatly require trx.
166 @tc.type: FUNC
167 */
168 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_003, TestSize.Level1)
169 {
170 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
171 std::vector<std::pair<int, uint64_t>> results = {};
172 for (uint32_t i = 0; i < 100; i++) { // Get 100 trxs
173 std::pair<int, uint64_t> res = {};
174 res = store->BeginTrans();
175 EXPECT_TRUE((res.first == E_OK) || (res.first == E_DATABASE_BUSY));
176 results.push_back(res);
177 }
178 for (uint32_t i = 0; i < 100; i++) { // Commit 100 trxs
179 if (results[i].first == E_OK) {
180 EXPECT_EQ(store->RollBack(results[i].second), E_OK);
181 }
182 }
183 }
184
185 /**
186 @tc.name: RdbStore_Execute_004
187 @tc.desc: test RdbStore Execute in vector mode
188 @tc.type: FUNC
189 */
190 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_004, TestSize.Level1)
191 {
192 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
193 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
194 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
195 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;";
196
197 std::pair<int32_t, ValueObject> res = {};
198 res = store->Execute(sqlCreateTable.c_str(), {}, 0);
199 EXPECT_EQ(res.first, E_OK);
200
201 std::pair<int, uint64_t> res1 = {};
202 res1 = store->BeginTrans();
203 EXPECT_EQ(res1.first, E_OK);
204 EXPECT_NE(res1.second, 0);
205
206 res = store->Execute(sqlInsert.c_str(), {}, res1.second);
207 EXPECT_EQ(res.first, E_OK);
208 EXPECT_EQ(store->Commit(res1.second), E_OK);
209 res = store->Execute("DROP TABLE test;", {}, 0);
210 EXPECT_EQ(res.first, E_OK);
211 }
212
213 /**
214 @tc.name: RdbStore_Execute_005
215 @tc.desc: test RdbStore Execute in vector mode
216 @tc.type: FUNC
217 */
218 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_005, TestSize.Level1)
219 {
220 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
221 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
222 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
223 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;";
224
225 std::pair<int32_t, ValueObject> res = {};
226 res = store->Execute(sqlCreateTable.c_str(), {});
227 EXPECT_EQ(res.first, E_OK);
228 res = store->Execute(sqlInsert.c_str(), {});
229 EXPECT_EQ(res.first, E_OK);
230 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlQuery.c_str(), std::vector<ValueObject>());
231 EXPECT_NE(resultSet, nullptr);
232 EXPECT_EQ(resultSet->GoToNextRow(), E_OK);
233 std::vector<std::string> colNames = {};
234 resultSet->GetAllColumnNames(colNames);
235 EXPECT_EQ(colNames.size(), 1);
236 int columnIndex = 0;
237 int intVal = 0;
238 resultSet->GetColumnIndex("id", columnIndex);
239 resultSet->GetInt(columnIndex, intVal);
240 EXPECT_EQ(columnIndex, 0);
241 EXPECT_EQ(intVal, 1);
242 EXPECT_EQ(E_OK, resultSet->Close());
243 res = store->Execute("DROP TABLE test;");
244 EXPECT_EQ(E_OK, res.first);
245 }
246
247 /**
248 @tc.name: RdbStore_Execute_006
249 @tc.desc: test RdbStore Execute in vector mode
250 @tc.type: FUNC
251 */
252 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_006, TestSize.Level1)
253 {
254 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
255 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
256 std::string sqlBeginTrans = "begin;";
257
258 std::string dbPath = "/data/test/execute_test1.db";
259 std::string configStr =
260 "{\"pageSize\":8, \"crcCheckEnable\":0, \"redoFlushByTrx\":1, \"bufferPoolSize\":10240,"
261 "\"sharedModeEnable\":1, \"metaInfoBak\":1, \"maxConnNum\":500, \"defaultIsolationLevel\":2 }";
262
263 GRD_DB *db2 = nullptr;
264 GRD_DB *db4 = nullptr;
265 EXPECT_EQ(RdUtils::RdDbOpen(dbPath.c_str(), configStr.c_str(),
266 GRD_DB_OPEN_CREATE | GRD_DB_OPEN_IGNORE_DATA_CORRPUPTION, &db2), E_OK);
267 EXPECT_EQ(RdUtils::RdDbOpen(dbPath.c_str(), configStr.c_str(),
268 GRD_DB_OPEN_CREATE | GRD_DB_OPEN_IGNORE_DATA_CORRPUPTION, &db4), E_OK);
269
270 GRD_SqlStmt *stmt = nullptr;
271 EXPECT_EQ(RdUtils::RdSqlPrepare(db2, sqlCreateTable.c_str(), sqlCreateTable.size(), &stmt, nullptr), E_OK);
272 EXPECT_EQ(RdUtils::RdSqlStep(stmt), E_OK);
273 EXPECT_EQ(RdUtils::RdSqlFinalize(stmt), E_OK);
274
275 stmt = nullptr;
276 EXPECT_EQ(RdUtils::RdSqlPrepare(db4, sqlBeginTrans.c_str(), sqlBeginTrans.size(), &stmt, nullptr), E_OK);
277 EXPECT_EQ(RdUtils::RdSqlStep(stmt), E_OK);
278 EXPECT_EQ(RdUtils::RdSqlFinalize(stmt), E_OK);
279
280 stmt = nullptr;
281 EXPECT_EQ(RdUtils::RdSqlPrepare(db4, sqlInsert.c_str(), sqlInsert.size(), &stmt, nullptr), E_OK);
282 EXPECT_EQ(RdUtils::RdSqlStep(stmt), E_OK);
283 EXPECT_EQ(RdUtils::RdSqlFinalize(stmt), E_OK);
284 EXPECT_EQ(RdUtils::RdDbClose(db2, 0), E_OK);
285 EXPECT_EQ(RdUtils::RdDbClose(db4, 0), E_OK);
286 }
287
GetRandVector(uint32_t maxElementNum,uint16_t dim)288 std::string GetRandVector(uint32_t maxElementNum, uint16_t dim)
289 {
290 if (maxElementNum == 0) {
291 return "";
292 }
293 unsigned int randomNumberSeed = time(nullptr);
294 std::string res = "[";
295 for (uint16_t i = 0; i < dim; i++) {
296 uint32_t intPart = (rand_r(&randomNumberSeed) % maxElementNum);
297 intPart += 1;
298 uint32_t tenths = (rand_r(&randomNumberSeed) % 10); // 10是用来限制小数点后的数字不能超过10
299 res += std::to_string(intPart);
300 res += ".";
301 res += std::to_string(tenths);
302 res += ", ";
303 }
304 res.pop_back();
305 res.pop_back();
306 res += "]";
307 return res;
308 }
309
310 constexpr uint32_t MAX_INT_PART = 10;
311 constexpr uint16_t LARGE_ANN_INDEX_DIM = 8;
CreateIdxAndSelect(std::string & sqlSelect)312 std::shared_ptr<ResultSet> CreateIdxAndSelect(std::string &sqlSelect)
313 {
314 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
315
316 std::string sqlCreateTable =
317 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
318 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
319
320 std::pair<int32_t, ValueObject> res = {};
321 res = store->Execute(sqlCreateTable.c_str(), {});
322 EXPECT_EQ(res.first, E_OK);
323 res = store->Execute(sqlCreateIndex.c_str(), {});
324 EXPECT_EQ(res.first, E_OK);
325 for (uint16_t i = 0; i < 10; i++) { // iterate 10 times to insert 10 data
326 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
327 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
328 res = store->Execute(sqlInsert.c_str(), {});
329 EXPECT_EQ(res.first, E_OK);
330 }
331 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
332 EXPECT_NE(resultSet, nullptr);
333
334 bool isStarted = false;
335 bool isAtFirstRow = false;
336 EXPECT_EQ(E_OK, resultSet->IsStarted(isStarted));
337 EXPECT_EQ(E_OK, resultSet->IsAtFirstRow(isAtFirstRow));
338 EXPECT_EQ(false, isStarted);
339 EXPECT_EQ(false, isAtFirstRow);
340
341 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
342 EXPECT_EQ(E_OK, resultSet->IsStarted(isStarted));
343 EXPECT_EQ(E_OK, resultSet->IsAtFirstRow(isAtFirstRow));
344 EXPECT_EQ(true, isStarted);
345 EXPECT_EQ(true, isAtFirstRow);
346
347 std::vector<std::string> colNames = {};
348 resultSet->GetAllColumnNames(colNames);
349 EXPECT_EQ(colNames.size(), 2); // Expect 2 columns
350 return resultSet;
351 }
352
353 /**
354 @tc.name: RdbStore_Execute_007
355 @tc.desc: test RdbStore Execute in vector mode
356 @tc.type: FUNC
357 */
358 constexpr uint16_t SELECT_RES_NUM = 3;
359 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_007, TestSize.Level1)
360 {
361 std::string sqlSelect = "SELECT * FROM test ORDER BY repr <-> '" +
362 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "' LIMIT " +
363 std::to_string(SELECT_RES_NUM) + ";";
364 std::shared_ptr<ResultSet> resultSet = CreateIdxAndSelect(sqlSelect);
365 int columnIndex = 0;
366 size_t vectSize = 0;
367 ValueObject::FloatVector vecs = {};
368 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
369 EXPECT_EQ(columnIndex, 1);
370
371 ColumnType colType = ColumnType::TYPE_NULL;
372 EXPECT_EQ(E_OK, resultSet->GetColumnType(columnIndex, colType));
373 EXPECT_EQ(ColumnType::TYPE_FLOAT32_ARRAY, colType);
374
375 EXPECT_EQ(E_OK, resultSet->GetFloat32Array(columnIndex, vecs));
376 EXPECT_EQ(E_OK, resultSet->GetSize(columnIndex, vectSize));
377 EXPECT_EQ(vecs.size(), LARGE_ANN_INDEX_DIM);
378 EXPECT_EQ(sizeof(float) * LARGE_ANN_INDEX_DIM, vectSize);
379
380 int idVal = 0;
381 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("id", columnIndex));
382 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, idVal));
383
384 int ret = E_OK;
385 int resCnt = 0;
386 vecs.clear();
387 while ((ret = resultSet->GoToNextRow() == E_OK)) {
388 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
389 EXPECT_EQ(1, columnIndex); // 1是向量的列
390
391 resultSet->GetColumnType(columnIndex, colType);
392 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT32_ARRAY);
393
394 EXPECT_EQ(E_COLUMN_OUT_RANGE, resultSet->GetColumnType(100, colType)); // 100是一个不存在的col, 所以预期返回NULL
395
396 EXPECT_EQ(E_OK, resultSet->GetFloat32Array(columnIndex, vecs));
397 EXPECT_EQ(E_OK, resultSet->GetSize(columnIndex, vectSize));
398 EXPECT_EQ(vecs.size(), LARGE_ANN_INDEX_DIM);
399 EXPECT_EQ(sizeof(float) * LARGE_ANN_INDEX_DIM, vectSize);
400 resCnt++;
401 }
402 EXPECT_EQ(SELECT_RES_NUM - 1, resCnt);
403 EXPECT_EQ(E_OK, resultSet->Close());
404 std::pair<int32_t, ValueObject> res = RdbExecuteRdTest::store->Execute("DROP TABLE test;");
405 EXPECT_EQ(E_OK, res.first);
406 }
407
408 /**
409 @tc.name: RdbStore_Execute_008
410 @tc.desc: test RdbStore Execute in vector mode
411 @tc.type: FUNC
412 */
413 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_008, TestSize.Level1)
414 {
415 std::string sqlSelect = "SELECT * FROM test;";
416 std::shared_ptr<ResultSet> resultSet = CreateIdxAndSelect(sqlSelect);
417 int columnIndex = 0;
418 size_t vectSize = 0;
419 ValueObject::FloatVector vecs = {};
420 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
421 EXPECT_EQ(columnIndex, 1);
422
423 ColumnType colType = ColumnType::TYPE_NULL;
424 EXPECT_EQ(E_OK, resultSet->GetColumnType(columnIndex, colType));
425 EXPECT_EQ(ColumnType::TYPE_FLOAT32_ARRAY, colType);
426
427 int idVal = 0;
428 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("id", columnIndex));
429 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, idVal));
430
431 int ret = E_OK;
432 int resCnt = 1;
433 vecs.clear();
434 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
435 while ((ret = resultSet->GoToNextRow() == E_OK)) {
436 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("repr", columnIndex));
437 EXPECT_EQ(1, columnIndex); // 1是向量的列， columnIndex期望是1
438
439 resultSet->GetColumnType(columnIndex, colType);
440 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT32_ARRAY);
441
442 EXPECT_EQ(E_OK, resultSet->GetFloat32Array(columnIndex, vecs));
443 EXPECT_EQ(E_OK, resultSet->GetSize(columnIndex, vectSize));
444 EXPECT_EQ(vecs.size(), LARGE_ANN_INDEX_DIM);
445 EXPECT_EQ(sizeof(float) * LARGE_ANN_INDEX_DIM, vectSize);
446 resCnt++;
447 }
448 EXPECT_EQ(10, resCnt); // 期待resCnt是10
449 EXPECT_EQ(E_OK, resultSet->Close());
450 std::pair<int32_t, ValueObject> res = RdbExecuteRdTest::store->Execute("DROP TABLE test;");
451 EXPECT_EQ(E_OK, res.first);
452 }
453
454 /**
455 @tc.name: RdbStore_Execute_009
456 @tc.desc: test RdbStore Execute in vector mode
457 @tc.type: FUNC
458 */
459 constexpr uint32_t EXPEC_INSERT_CNT_FOR = 10;
460 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_009, TestSize.Level1)
461 {
462 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
463
464 std::string sqlCreateTable =
465 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
466 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
467 std::string sqlSelect = "SELECT * FROM test;";
468
469 std::pair<int32_t, ValueObject> res = {};
470 res = store->Execute(sqlCreateTable.c_str(), {});
471 EXPECT_EQ(res.first, E_OK);
472
473 std::pair<int32_t, int64_t> trx = {};
474 trx = store->BeginTrans();
475 EXPECT_EQ(trx.first, E_OK);
476
477 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
478 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
479 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
480 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
481 EXPECT_EQ(res.first, E_OK);
482 }
483 EXPECT_EQ(E_OK, store->Commit(trx.second));
484
485 res = store->Execute(sqlCreateIndex.c_str(), {});
486 EXPECT_EQ(res.first, E_OK);
487
488 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
489 EXPECT_NE(resultSet, nullptr);
490
491 int32_t resCnt = 0;
492 while (resultSet->GoToNextRow() == E_OK) {
493 resCnt++;
494 }
495 EXPECT_EQ(EXPEC_INSERT_CNT_FOR, resCnt);
496 }
497
498 /**
499 @tc.name: RdbStore_Execute_010
500 @tc.desc: test RdbStore Execute in vector mode
501 @tc.type: FUNC
502 */
503 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_010, TestSize.Level1)
504 {
505 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
506
507 std::string sqlCreateTable =
508 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
509 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
510 std::string sqlSelect = "SELECT * FROM test;";
511
512 std::pair<int32_t, ValueObject> res = {};
513 res = store->Execute(sqlCreateTable.c_str(), {});
514 EXPECT_EQ(res.first, E_OK);
515
516 for (uint16_t i = 0; i < 10; i++) {
517 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
518 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
519 res = store->Execute(sqlInsert.c_str(), {}, 0);
520 EXPECT_EQ(res.first, E_OK);
521 }
522
523 std::pair<int32_t, int64_t> trx = {};
524 trx = store->BeginTrans();
525 EXPECT_EQ(trx.first, E_OK);
526 EXPECT_NE(trx.second, 0);
527
528 for (uint16_t i = 0; i < 10; i++) {
529 std::string sqlDelete = "DELETE FROM test WHERE id = 1000000" + std::to_string(i) + ";";
530 res = store->Execute(sqlDelete.c_str(), {}, trx.second);
531 EXPECT_EQ(res.first, E_OK);
532 }
533
534 EXPECT_EQ(E_OK, store->Commit(trx.second));
535
536 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
537 EXPECT_NE(resultSet, nullptr);
538 EXPECT_EQ(E_ROW_OUT_RANGE, resultSet->GoToNextRow());
539 }
540
541 /**
542 @tc.name: RdbStore_Execute_011
543 @tc.desc: test RdbStore Execute in vector mode
544 @tc.type: FUNC
545 */
546 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_011, TestSize.Level1)
547 {
548 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
549
550 std::string sqlCreateTable = "CREATE TABLE test(id int primary key, day int, repr floatvector(" +
551 std::to_string(LARGE_ANN_INDEX_DIM) + "));";
552 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
553 std::string sqlSelect = "SELECT * FROM test;";
554
555 std::pair<int32_t, ValueObject> res = {};
556 res = store->Execute(sqlCreateTable.c_str(), {});
557 EXPECT_EQ(res.first, E_OK);
558
559 for (uint16_t i = 0; i < 10; i++) {
560 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", 0, '" +
561 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
562 res = store->Execute(sqlInsert.c_str(), {}, 0);
563 EXPECT_EQ(res.first, E_OK);
564 }
565
566 std::pair<int32_t, int64_t> trx = {};
567 trx = store->BeginTrans();
568 EXPECT_EQ(trx.first, E_OK);
569 EXPECT_NE(trx.second, 0);
570
571 for (uint16_t i = 0; i < 10; i++) {
572 std::string sqlDelete = "UPDATE test SET day = 1 WHERE id = 1000000" + std::to_string(i) + ";";
573 res = store->Execute(sqlDelete.c_str(), {}, trx.second);
574 EXPECT_EQ(res.first, E_OK);
575 }
576
577 EXPECT_EQ(E_OK, store->Commit(trx.second));
578 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
579 EXPECT_NE(resultSet, nullptr);
580
581 uint32_t resCnt = 0;
582 int64_t intVal = 0;
583 int columnIndex = 0;
584 ColumnType colType = ColumnType::TYPE_NULL;
585
586 while (resultSet->GoToNextRow() == E_OK) {
587 std::vector<std::string> colNames = {};
588 resultSet->GetAllColumnNames(colNames);
589 EXPECT_STREQ("id", colNames[0].c_str());
590 EXPECT_STREQ("day", colNames[1].c_str());
591 EXPECT_STREQ("repr", colNames[2].c_str());
592
593 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("day", columnIndex));
594 EXPECT_EQ(1, columnIndex); // 1是day的列
595
596 EXPECT_EQ(E_OK, resultSet->GetColumnType(columnIndex, colType));
597 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
598
599 EXPECT_EQ(
600 E_COLUMN_OUT_RANGE, resultSet->GetColumnType(100, colType)); // 100是一个不存在的col, 所以预期返回错误码
601 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER); // 值不会被更新
602
603 EXPECT_EQ(E_OK, resultSet->GetLong(columnIndex, intVal));
604 EXPECT_EQ(1, intVal);
605
606 resCnt++;
607 }
608 }
609
610 /**
611 @tc.name: RdbStore_Execute_012
612 @tc.desc: test RdbStore Execute in vector mode
613 @tc.type: FUNC
614 */
615 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_012, TestSize.Level1)
616 {
617 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
618
619 std::string sqlCreateTable =
620 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
621 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
622 std::string sqlSelect = "SELECT * FROM test;";
623
624 std::pair<int32_t, ValueObject> res = {};
625 res = store->Execute(sqlCreateTable.c_str(), {});
626 EXPECT_EQ(res.first, E_OK);
627
628 std::pair<int32_t, int64_t> trx = {};
629 trx = store->BeginTrans();
630 EXPECT_EQ(trx.first, E_OK);
631
632 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
633 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
634 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
635 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
636 EXPECT_EQ(res.first, E_OK);
637 }
638 EXPECT_EQ(E_OK, store->RollBack(trx.second));
639
640 res = store->Execute(sqlCreateIndex.c_str(), {});
641 EXPECT_EQ(res.first, E_OK);
642
643 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
644 EXPECT_NE(resultSet, nullptr);
645
646 int32_t resCnt = 0;
647 while (resultSet->GoToNextRow() == E_OK) {
648 resCnt++;
649 }
650 EXPECT_EQ(0, resCnt);
651 }
652
653 /**
654 @tc.name: RdbStore_Execute_013
655 @tc.desc: test RdbStore Execute in vector mode
656 @tc.type: FUNC
657 */
658 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_013, TestSize.Level1)
659 {
660 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
661
662 std::string sqlCreateTable =
663 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(LARGE_ANN_INDEX_DIM) + "));";
664 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
665 std::string sqlSelect = "SELECT * FROM test;";
666
667 std::pair<int32_t, ValueObject> res = {};
668 res = store->Execute(sqlCreateTable.c_str(), {});
669 EXPECT_EQ(res.first, E_OK);
670
671 std::pair<int32_t, int64_t> trx = {};
672 trx = store->BeginTrans();
673 EXPECT_EQ(trx.first, E_OK);
674
675 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
676 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
677 GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
678 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
679 EXPECT_EQ(res.first, E_OK);
680 }
681 EXPECT_EQ(E_OK, store->RollBack(trx.second));
682
683 res = store->Execute(sqlCreateIndex.c_str(), {});
684 EXPECT_EQ(res.first, E_OK);
685
686 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
687 EXPECT_NE(resultSet, nullptr);
688
689 int32_t resCnt = 0;
690 while (resultSet->GoToNextRow() == E_OK) {
691 resCnt++;
692 }
693 EXPECT_EQ(0, resCnt);
694 }
695
696 /**
697 @tc.name: RdbStore_Execute_014
698 @tc.desc: test RdbStore Execute update in transaction
699 @tc.type: FUNC
700 */
701 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_014, TestSize.Level1)
702 {
703 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
704
705 std::string sqlCreateTable = "CREATE TABLE test(id int primary key, age int, repr floatvector(" +
706 std::to_string(LARGE_ANN_INDEX_DIM) + "));";
707 std::string sqlCreateIndex = "CREATE INDEX diskann_l2_idx ON test USING GSIVFFLAT(repr L2);";
708 std::string sqlSelect = "SELECT * FROM test;";
709
710 std::pair<int32_t, ValueObject> res = {};
711 res = store->Execute(sqlCreateTable.c_str(), {});
712 EXPECT_EQ(res.first, E_OK);
713
714 for (uint16_t i = 0; i < 10; i++) {
715 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", " + std::to_string(i) +
716 ", '" + GetRandVector(MAX_INT_PART, LARGE_ANN_INDEX_DIM) + "');";
717 res = store->Execute(sqlInsert.c_str(), {}, 0);
718 EXPECT_EQ(res.first, E_OK);
719 }
720
721 std::pair<int32_t, int64_t> trx = {};
722 trx = store->BeginTrans();
723 EXPECT_EQ(trx.first, E_OK);
724 EXPECT_NE(trx.second, 0);
725
726 for (uint16_t i = 0; i < 10; i++) {
727 std::string sqlUpdate = "UPDATE test SET age = 1 WHERE id = 1000000" + std::to_string(i) + ";";
728 res = store->Execute(sqlUpdate.c_str(), {}, trx.second);
729 EXPECT_EQ(res.first, E_OK);
730 }
731
732 EXPECT_EQ(E_OK, store->Commit(trx.second));
733 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
734 int columnIndex = 0;
735 while (resultSet->GoToNextRow() == E_OK) {
736 std::vector<std::string> colNames = {};
737 resultSet->GetAllColumnNames(colNames);
738 EXPECT_STREQ("id", colNames[0].c_str());
739 EXPECT_STREQ("age", colNames[1].c_str());
740 EXPECT_STREQ("repr", colNames[2].c_str());
741
742 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("age", columnIndex));
743 EXPECT_EQ(1, columnIndex); // 1是age的列
744 int result;
745 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, result));
746 EXPECT_EQ(result, 1);
747 }
748 }
749
750 /**
751 @tc.name: RdbStore_Execute_014
752 @tc.desc: test RdbStore Execute Repeatly Get Transaction
753 @tc.type: FUNC
754 */
755 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_015, TestSize.Level1)
756 {
757 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
758
759 std::string sqlCreateTable = "CREATE TABLE test2 (id INTEGER PRIMARY KEY, repr INTEGER);";
760 std::string sqlSelect = "SELECT * FROM test2;";
761
762 std::pair<int32_t, ValueObject> res = {};
763 res = store->Execute(sqlCreateTable.c_str(), {});
764 EXPECT_EQ(res.first, E_OK);
765
766 for (uint32_t i = 0; i < 10; i++) {
767 std::pair<int32_t, int64_t> trx = {};
768 trx = store->BeginTrans();
769 EXPECT_EQ(trx.first, E_OK);
770 std::string sqlInsert = "INSERT INTO test2 VALUES(" + std::to_string(i) + ", 1);";
771 res = store->Execute(sqlInsert.c_str(), {}, trx.second);
772 EXPECT_EQ(res.first, E_OK);
773 EXPECT_EQ(E_OK, store->Commit(trx.second));
774 }
775
776 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
777 EXPECT_NE(resultSet, nullptr);
778
779 int32_t resCnt = 0;
780 while (resultSet->GoToNextRow() == E_OK) {
781 int rowIdx = 0;
782 resultSet->GetRowIndex(rowIdx);
783 EXPECT_EQ(resCnt, rowIdx);
784 resCnt++;
785 }
786 EXPECT_EQ(10, resCnt);
787 }
788
789 /**
790 @tc.name: RdbStore_Execute_016
791 @tc.desc: test RdbStore Execute Repeatly Get Transaction
792 @tc.type: FUNC
793 */
794 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_016, TestSize.Level1)
795 {
796 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
797 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test1 (docId Text, str Text, repr floatvector(4));";
798 std::string sqlCreateIdx = "CREATE INDEX test_idx ON test1 USING GSIVFFLAT(repr L2);";
799 std::string sqlSelect = "SELECT * FROM test1 ORDER BY repr <-> '[1.0, 2.0, 3.0, 4.0]' LIMIT 2;";
800
801 std::pair<int32_t, ValueObject> res = store->Execute(sqlCreateTable.c_str(), {});
802 EXPECT_EQ(res.first, E_OK);
803 res = store->Execute(sqlCreateIdx.c_str(), {});
804 EXPECT_EQ(res.first, E_OK);
805
806 std::vector<std::vector<float>> vectorSamples = { { 1.0, 2.0, 3.0, 4.0 }, { 10, 20, 30, 40 },
807 { 100, 200, 300, 400 } };
808
809 for (uint32_t i = 0; i < vectorSamples.size(); i++) {
810 std::pair<int32_t, int64_t> trx = {};
811 trx = store->BeginTrans();
812 EXPECT_EQ(trx.first, E_OK);
813 std::string sqlInsert = "insert into test1 values('" + std::to_string(i) + "', ?, ?);";
814 ValueObject floatObj = ValueObject(vectorSamples[i]);
815 ValueObject::FloatVector vector = {};
816 EXPECT_EQ(floatObj.GetVecs(vector), E_OK);
817 EXPECT_EQ(vectorSamples[i].size(), vector.size());
818 for (size_t j = 0; j < vector.size(); j++) {
819 EXPECT_FLOAT_EQ(vectorSamples[i][j], vector[j]);
820 }
821
822 res = store->Execute(sqlInsert.c_str(), { ValueObject(std::string("textVal")), floatObj }, trx.second);
823 EXPECT_EQ(res.first, E_OK);
824 EXPECT_EQ(E_OK, store->Commit(trx.second));
825 }
826
827 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
828 EXPECT_NE(resultSet, nullptr);
829
830 int32_t resCnt = 0;
831 while (resultSet->GoToNextRow() == E_OK) {
832 std::string primaryStrVal = "";
833 std::string textStrVal = "";
834 ValueObject::FloatVector floatVector = {};
835 resultSet->GetString(0, primaryStrVal); // 0 is the index of primary String column in select projection
836 resultSet->GetString(1, textStrVal); // 1 is the index of TEXT column in select projection
837 resultSet->GetFloat32Array(2, floatVector); // 2 is the index of vector column in select projection
838 EXPECT_STREQ(std::to_string(resCnt).c_str(), primaryStrVal.c_str());
839 EXPECT_STREQ("textVal", textStrVal.c_str());
840 EXPECT_EQ(vectorSamples[resCnt].size(), floatVector.size());
841 for (size_t i = 0; i < floatVector.size(); i++) {
842 EXPECT_FLOAT_EQ(vectorSamples[resCnt][i], floatVector[i]);
843 }
844 resCnt++;
845 }
846 EXPECT_EQ(2, resCnt); // Expect 2 result due to limit 2
847 }
848
849 /**
850 @tc.name: RdbStore_Execute_017
851 @tc.desc: test RdbStore Execute Getting or Setting version
852 @tc.type: FUNC
853 */
854 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_017, TestSize.Level1)
855 {
856 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
857 int versionToGet = 0;
858 int versionToSet = 1;
859 EXPECT_EQ(E_OK, store->SetVersion(versionToSet));
860 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
861 EXPECT_EQ(versionToGet, versionToSet);
862
863 std::string sqlPragmaSetVersion = "PRAGMA user_version = 3";
864 std::pair<int32_t, ValueObject> res = {};
865 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
866 EXPECT_EQ(res.first, E_OK);
867 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
868 EXPECT_EQ(versionToGet, 3); // 3 is set by sql
869
870 sqlPragmaSetVersion = "PRAGMA user_version = 4;";
871 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
872 EXPECT_EQ(res.first, E_OK);
873 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
874 EXPECT_EQ(versionToGet, 4); // 4 is set by sql
875
876 sqlPragmaSetVersion = "PRAGMA user_version = 35678";
877 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
878 EXPECT_EQ(res.first, E_OK);
879 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
880 EXPECT_EQ(versionToGet, 35678); // 35678 is set by sql
881
882 sqlPragmaSetVersion = "PRAGMA user_version = asdfds";
883 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
884 EXPECT_EQ(res.first, E_INCORRECT_SQL);
885
886 sqlPragmaSetVersion = "PRAGMA user_version = ;";
887 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
888 EXPECT_EQ(res.first, E_INCORRECT_SQL);
889
890 sqlPragmaSetVersion = "PRAGMA user_version = 456 ";
891 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
892 EXPECT_EQ(res.first, E_OK);
893 EXPECT_EQ(E_OK, store->GetVersion(versionToGet));
894 EXPECT_EQ(versionToGet, 456); // 456 is set by sql
895
896 sqlPragmaSetVersion = "PRAGMA user_version = 456 1231 ";
897 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
898 EXPECT_EQ(res.first, E_INCORRECT_SQL);
899
900 sqlPragmaSetVersion = "PRAGMA user_version = 456 1asdf231 ";
901 res = store->Execute(sqlPragmaSetVersion.c_str(), {}, 0);
902 EXPECT_EQ(res.first, E_INCORRECT_SQL);
903 }
904
905 /**
906 @tc.name: RdbStore_Execute_018
907 @tc.desc: test RdbStore create encrypted db from non-encrypted db
908 @tc.type: FUNC
909 */
910 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_018, TestSize.Level1)
911 {
912 RdbExecuteRdTest::store = nullptr;
913 bool isOriginDbEncrypt = GetParam();
914
915 RdbStoreConfig config(RdbExecuteRdTest::databaseName);
916 config.SetIsVector(true);
917 config.SetEncryptStatus(!isOriginDbEncrypt);
918 ExecuteTestOpenRdCallback helper;
919 int errCode = E_OK;
920 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
921 // open encrypted-db in un-encrypted mode is not allowed
922 // open un-encrypted db in encrypted-db is allowed
923 EXPECT_TRUE((isOriginDbEncrypt && RdbExecuteRdTest::store == nullptr) ||
924 (!isOriginDbEncrypt && RdbExecuteRdTest::store != nullptr));
925 if (!isOriginDbEncrypt) {
926 RdbExecuteRdTest::store = nullptr;
927 config.SetEncryptStatus(false); // open encrypted-db update from un-encrypt in un-encrypted mode is not allowed
928 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
929 EXPECT_EQ(store, nullptr);
930 }
931 }
932
933 /**
934 @tc.name: RdbStore_Execute_019
935 @tc.desc: test RdbStore Execute in vector mode, empty string bind case.
936 @tc.type: FUNC
937 */
938 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_019, TestSize.Level1)
939 {
940 std::string sqlCreateTable
941 = "CREATE TABLE IF NOT EXISTS testEmptyString (id INTEGER PRIMARY KEY, name text, repr floatvector(8));";
942 std::string sqlInsert = "INSERT INTO testEmptyString VALUES(?, ?, ?);";
943 std::string sqlQuery = "SELECT id FROM testEmptyString";
944 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
945 std::vector<float> floatVector = { 1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4 };
946 std::vector bindArgs = std::vector{ ValueObject(1), ValueObject(""), ValueObject(floatVector)};
947
948 EXPECT_EQ(store->Execute(sqlCreateTable).first, E_OK);
949 EXPECT_EQ(store->Execute(sqlInsert, bindArgs).first, E_OK);
950
951 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlQuery);
952 ASSERT_NE(resultSet, nullptr);
953 int32_t rowCount = 0;
954 EXPECT_EQ(resultSet->GetRowCount(rowCount), E_OK);
955 EXPECT_EQ(rowCount, 1);
956 }
957
958 /**
959 * @tc.name: RdbStore_Execute_020
960 * @tc.desc: Vector database transaction testing. If the SQL execution fails, the transaction is not closed.
961 * @tc.type: FUNC
962 */
963 HWTEST_P(RdbExecuteRdTest, RdbStore_Execute_020, TestSize.Level0)
964 {
965 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
966 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
967 std::string sqlInsert1 = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
968 std::string sqlInsert2 = "INSERT INTO test VALUES(2, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
969 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;";
970
971 std::pair<int32_t, ValueObject> res = {};
972 res = store->Execute(sqlCreateTable, {}, 0);
973 EXPECT_EQ(res.first, E_OK);
974
975 auto [ret1, transId1] = store->BeginTrans();
976 EXPECT_EQ(ret1, E_OK);
977 EXPECT_GE(transId1, 0);
978
979 res = store->Execute(sqlInsert1, {}, transId1);
980 EXPECT_EQ(res.first, E_OK);
981
982 auto [ret2, transId2] = store->BeginTrans();
983 EXPECT_EQ(ret2, E_OK);
984 EXPECT_GE(transId2, 0);
985
986 res = store->Execute(sqlInsert2, {}, transId2);
987 EXPECT_EQ(res.first, E_DATABASE_BUSY);
988
989 EXPECT_EQ(store->Commit(transId2), E_OK);
990 EXPECT_EQ(store->Commit(transId1), E_OK);
991 res = store->Execute("DROP TABLE test;", {}, 0);
992 EXPECT_EQ(res.first, E_OK);
993 }
994
995 /* *
996 * @tc.name: Rdb_BackupRestoreTest_001
997 * @tc.desc: backup and restore
998 * @tc.type: FUNC
999 */
1000 HWTEST_P(RdbExecuteRdTest, Rdb_BackupRestoreTest_001, TestSize.Level2)
1001 {
1002 //create new db instance
1003 int errCode = E_OK;
1004 RdbStoreConfig config(RdbExecuteRdTest::restoreDatabaseName);
1005 config.SetIsVector(true);
1006 config.SetSecurityLevel(SecurityLevel::S4);
1007 config.SetEncryptStatus(GetParam());
1008 if (GetParam()) { // check if encrypt
1009 config.SetHaMode(HAMode::MAIN_REPLICA);
1010 }
1011 config.SetAllowRebuild(true);
1012 ExecuteTestOpenRdCallback helper;
1013 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1014 EXPECT_EQ(errCode, E_OK);
1015 EXPECT_NE(store, nullptr);
1016
1017 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
1018 std::string sqlInsert = "INSERT INTO test VALUES(1, '[1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4]');";
1019 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;";
1020
1021 std::pair<int32_t, ValueObject> res = {};
1022 res = store->Execute(sqlCreateTable.c_str(), {});
1023 EXPECT_EQ(res.first, E_OK);
1024 res = store->Execute(sqlInsert.c_str(), {});
1025 EXPECT_EQ(res.first, E_OK);
1026
1027 std::vector<uint8_t> encryptKey;
1028 if (GetParam()) {
1029 encryptKey = config.GetEncryptKey();
1030 }
1031
1032 int ret = store->Backup(RdbExecuteRdTest::backupDatabaseName, encryptKey);
1033 EXPECT_EQ(ret, E_OK);
1034
1035 res = store->Execute("delete from test where id = 1;");
1036 EXPECT_EQ(E_OK, res.first);
1037
1038 ret = store->Restore(RdbExecuteRdTest::backupDatabaseName, encryptKey);
1039 EXPECT_EQ(ret, E_OK);
1040
1041 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlQuery.c_str(), std::vector<ValueObject>());
1042
1043 //check the result
1044 EXPECT_NE(resultSet, nullptr);
1045 EXPECT_EQ(resultSet->GoToNextRow(), E_OK);
1046 std::vector<std::string> colNames = {};
1047 resultSet->GetAllColumnNames(colNames);
1048 EXPECT_EQ(colNames.size(), 1);
1049 int columnIndex = 0;
1050 int intVal = 0;
1051 resultSet->GetColumnIndex("id", columnIndex);
1052 resultSet->GetInt(columnIndex, intVal);
1053 EXPECT_EQ(columnIndex, 0);
1054 EXPECT_EQ(intVal, 1);
1055 EXPECT_EQ(E_OK, resultSet->Close());
1056 res = store->Execute("DROP TABLE test;");
1057 EXPECT_EQ(E_OK, res.first);
1058
1059 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::restoreDatabaseName);
1060 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::backupDatabaseName);
1061 }
1062
1063 /* *
1064 * @tc.name: Rdb_IsUsingArkDataTest_001
1065 * @tc.desc: IsUsingArkData function test
1066 * @tc.type: FUNC
1067 */
1068 HWTEST_P(RdbExecuteRdTest, Rdb_IsUsingArkDataTest_001, TestSize.Level2)
1069 {
1070 EXPECT_EQ(OHOS::NativeRdb::RdbHelper::IsSupportArkDataDb(), true);
1071 }
1072
1073 /**
1074 * @tc.name: RdbStore_BatchInsert_001
1075 * @tc.desc: test RdbStore BatchInsert in vector mode
1076 * @tc.type: FUNC
1077 */
1078 HWTEST_P(RdbExecuteRdTest, RdbStore_BatchInsert_001, TestSize.Level1)
1079 {
1080 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1081 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, repr floatvector(8));";
1082 std::string sqlQuery = "SELECT * FROM test order by repr <-> '[1.1, 0.3, 2.2, 6.6, 1.5, 3.1, 0.6, 0.2]' limit 3;";
1083
1084 std::pair<int32_t, ValueObject> res = {};
1085 std::pair<int, int64_t> resBatch = {};
1086 res = store->Execute(sqlCreateTable.c_str(), {}, 0);
1087 EXPECT_EQ(res.first, E_OK);
1088 std::vector<float> vec = {1.2, 0.3, 3.2, 1.6, 2.5, 3.1, 0.8, 0.4};
1089
1090 int id = 0;
1091 std::cout << "Start BatchInsert" << std::endl;
1092 auto start = std::chrono::high_resolution_clock::now();
1093
1094 for (int32_t batch = 0; batch < BATCH_TOTAL_SIZE / BATCH_SIZE; batch++) {
1095 ValuesBuckets rows;
1096 for (int32_t i = 0; i < BATCH_SIZE; i++) {
1097 ValuesBucket row;
1098 row.PutInt("id", id++);
1099 row.Put("repr", vec);
1100 rows.Put(row);
1101 }
1102 resBatch = store->BatchInsert("test", rows);
1103 EXPECT_EQ(resBatch.first, E_OK);
1104 EXPECT_EQ(resBatch.second, BATCH_SIZE);
1105 }
1106
1107 auto end = std::chrono::high_resolution_clock::now();
1108 std::chrono::duration<double> duration = end - start;
1109 std::cout << "Insert Cost Time: " << duration.count() << " seconds" << std::endl;
1110 std::cout << "Ops: " << BATCH_TOTAL_SIZE / (duration.count() * 1000) << " Kops/s" << std::endl;
1111
1112 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlQuery.c_str(), std::vector<ValueObject>());
1113
1114 int32_t resCnt = 0;
1115 int32_t resId = -1;
1116 while (resultSet->GoToNextRow() == E_OK) {
1117 ValueObject::FloatVector floatVector = {};
1118 resultSet->GetInt(0, resId); // 0 is the index of primary INTEGER column in select projection
1119 resultSet->GetFloat32Array(1, floatVector); // 1 is the index of vector column in select projection
1120 EXPECT_EQ(resCnt, resId);
1121 EXPECT_EQ(vec.size(), floatVector.size());
1122 for (size_t i = 0; i < floatVector.size(); i++) {
1123 EXPECT_FLOAT_EQ(vec[i], floatVector[i]);
1124 }
1125 resCnt++;
1126 }
1127 EXPECT_EQ(3, resCnt); // Expect 3 result due to limit 3
1128
1129 res = store->Execute("DROP TABLE test;", {}, 0);
1130 EXPECT_EQ(res.first, E_OK);
1131 }
1132
1133 /**
1134 * @tc.name: RdbStore_BatchInsert_002
1135 * @tc.desc: test RdbStore BatchInsert performance in vector mode
1136 * @tc.type: FUNC
1137 */
1138 HWTEST_P(RdbExecuteRdTest, RdbStore_BatchInsert_002, TestSize.Level1)
1139 {
1140 std::string testStr2k = R"(
1141 {"$type":"root", "width":"1260.000000", "height":"2720.000000", "$resolution":"3.250000", "pageUrl":"pages/AppIndex",
1142 "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":"__Common__", "$rect":"[0.00, 0.00],
1143 [1260.00, 2720.00]", "$attrs":{}, "$children":[{"$type":"Navigation", "$rect":"[0.00, 0.00], [1260.00, 2720.00]",
1144 "$attrs":{"id":"mixnavigator", "enabled":"1", "focusable":"1"}, "$children":[{"$type":"NavigationContent", "$rect":"
1145 [0.00, 0.00], [1260.00, 2720.00]", "$attrs":{}, "$children":[{"$type":"NavDestination", "$rect":"[0.00, 0.00],
1146 [1260.00, 2720.00]", "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":"NavDestinationContent",
1147 "$rect":"[0.00, 0.00], [1260.00, 2720.00]", "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":"Stack",
1148 "$rect":"[0.00, 0.00], [1260.00, 2720.00]", "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":
1149 "__Common__", "$rect":"[0.00, 0.00], [1260.00, 2629.00]", "$attrs":{}, "$children":[{"$type":"Stack", "$rect":"
1150 [0.00, 0.00], [1260.00, 2629.00]", "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":"Stack", "$rect":"
1151 [0.00, 0.00], [1260.00, 2629.00]", "$attrs":{"id":"0", "enabled":"1", "focusable":"1"}, "$children":[{"$type":"Column",
1152 "$rect":"[0.00, 0.00], [1260.00, 2629.00]", "$attrs":{"id":"1", "enabled":"1", "focusable":"1"}, "$children":[{"$type":
1153 "Tabs", "$rect":"[0.00, 0.00], [1260.00, 2629.00]", "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":
1154 "Swiper", "$rect":"[0.00, 0.00], [1260.00, 2460.00]", "$attrs":{"enabled":"1", "focusable":"1"}, "$children":[{"$type":
1155 "TabContent", "$rect":"[0.00, 0.00], [1260.00, 2460.00]", "$attrs":{}, "$children":[{"$type":"Column", "$rect":"
1156 [0.00, 0.00], [1260.00, 2460.00]", "$attrs":{"id":"14", "enabled":"1", "focusable":"1"}, "$children":[{"$type":
1157 "Column", "$rect":"[0.00, 0.00], [1260.00, 2460.00]", "$attrs":{""}, "$children":[{"$attrs":{"id":"540", "enabled":"1",
1158 "focusable":"1"}, "$children":[{"$type":"GridCol", "$children":[{"$type":"Column", "$rect":"[0.00, 2460.00],
1159 [315.00, 2629.00]", "$attrs":{"enabled":"1", "focusable":"0"}, "$children":[{")";
1160
1161 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1162 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, name TEXT);";
1163
1164 std::pair<int32_t, ValueObject> res = {};
1165 std::pair<int, int64_t> resBatch = {};
1166 res = store->Execute(sqlCreateTable.c_str(), {}, 0);
1167 EXPECT_EQ(res.first, E_OK);
1168
1169 int id = 0;
1170 std::cout << "Start BatchInsert" << std::endl;
1171 auto start = std::chrono::high_resolution_clock::now();
1172
1173 for (int32_t batch = 0; batch < BATCH_TOTAL_SIZE / BATCH_SIZE; batch++) {
1174 ValuesBuckets rows;
1175 for (int32_t i = 0; i < BATCH_SIZE; i++) {
1176 ValuesBucket row;
1177 row.PutInt("id", id++);
1178 row.PutString("name", testStr2k);
1179 rows.Put(row);
1180 }
1181 resBatch = store->BatchInsert("test", rows);
1182 EXPECT_EQ(resBatch.first, E_OK);
1183 EXPECT_EQ(resBatch.second, BATCH_SIZE);
1184 }
1185
1186 auto end = std::chrono::high_resolution_clock::now();
1187 std::chrono::duration<double> duration = end - start;
1188 std::cout << "Insert Cost Time: " << duration.count() << " seconds" << std::endl;
1189 std::cout << "Ops: " << BATCH_TOTAL_SIZE / (duration.count() * 1000) << " Kops/s" << std::endl;
1190
1191 res = store->Execute("DROP TABLE test;", {}, 0);
1192 EXPECT_EQ(res.first, E_OK);
1193 }
1194
1195 /**
1196 * @tc.name: RdbStore_BatchInsert_003
1197 * @tc.desc: test RdbStore BatchInsert performance in vector mode
1198 * @tc.type: FUNC
1199 */
1200 HWTEST_P(RdbExecuteRdTest, RdbStore_BatchInsert_003, TestSize.Level1)
1201 {
1202 std::string testStr2k = R"({"$type":"root"})";
1203
1204 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1205 std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, name TEXT);";
1206
1207 std::pair<int32_t, ValueObject> res = {};
1208 std::pair<int, int64_t> resBatch = {};
1209 res = store->Execute(sqlCreateTable.c_str(), {}, 0);
1210 EXPECT_EQ(res.first, E_OK);
1211
1212 int id = 0;
1213 std::cout << "Start BatchInsert" << std::endl;
1214 auto start = std::chrono::high_resolution_clock::now();
1215 int maxVariableNum = MAX_VARIABLE_NUM / 2;
1216
1217 for (int32_t batch = 0; batch < 1; batch++) {
1218 ValuesBuckets rows;
1219 for (int32_t i = 0; i < maxVariableNum; i++) {
1220 ValuesBucket row;
1221 row.PutInt("id", id++);
1222 row.PutString("name", testStr2k);
1223 rows.Put(row);
1224 }
1225 resBatch = store->BatchInsert("test", rows);
1226 EXPECT_EQ(resBatch.first, E_OK);
1227 EXPECT_EQ(resBatch.second, maxVariableNum);
1228 }
1229
1230 auto end = std::chrono::high_resolution_clock::now();
1231 std::chrono::duration<double> duration = end - start;
1232 std::cout << "Insert Cost Time: " << duration.count() << " seconds" << std::endl;
1233 std::cout << "Ops: " << maxVariableNum / (duration.count() * 1000) << " Kops/s" << std::endl;
1234
1235 res = store->Execute("DROP TABLE test;", {}, 0);
1236 EXPECT_EQ(res.first, E_OK);
1237 }
1238
1239 constexpr uint16_t CLUSTER_INDEX_DIM = 256;
1240
ClusterAlgoByEvenNumber(ClstAlgoParaT * para)1241 int32_t ClusterAlgoByEvenNumber(ClstAlgoParaT *para)
1242 {
1243 int *result = para->clusterResult;
1244 const int specialId = 985;
1245 for (uint32_t i = 0; i < para->newFeaturesNum; i++) {
1246 result[i] = specialId;
1247 }
1248 std::cout << "ClusterAlgoByEvenNumber exec!" << std::endl;
1249 return 0;
1250 }
1251
1252 /**
1253 * @tc.name: RdbStore_RegisterAlgo_001
1254 * @tc.desc: test RdbStore RegisterAlgo in vector mode
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_P(RdbExecuteRdTest, RdbStore_RegisterAlgo_001, TestSize.Level1)
1258 {
1259 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1260 std::string algoName = "clst_algo_v0";
1261 int ret = store->RegisterAlgo(algoName, nullptr);
1262 EXPECT_EQ(ret, E_NO_MORE_ROWS);
1263 ret = store->RegisterAlgo(algoName, ClusterAlgoByEvenNumber);
1264 EXPECT_EQ(ret, E_OK);
1265
1266 std::string sqlCreateTable =
1267 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(CLUSTER_INDEX_DIM) + "));";
1268 std::string sqlCreateIndex =
1269 "CREATE INDEX ivfcluster_l2_idx ON test USING IVFCLUSTER(repr L2) with (CLUSTER_ALGO='clst_algo_v0');";
1270 std::string sqlSelect = "SELECT id, repr, CLUSTER_ID(repr) from test;";
1271
1272 std::pair<int32_t, ValueObject> res = {};
1273 res = store->Execute(sqlCreateTable.c_str(), {});
1274 EXPECT_EQ(res.first, E_OK);
1275
1276 res = store->Execute(sqlCreateIndex.c_str(), {});
1277 EXPECT_EQ(res.first, E_OK);
1278
1279 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
1280 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
1281 GetRandVector(MAX_INT_PART, CLUSTER_INDEX_DIM) + "');";
1282 res = store->Execute(sqlInsert.c_str(), {});
1283 EXPECT_EQ(res.first, E_OK);
1284 }
1285
1286 ret = store->RegisterAlgo(algoName, nullptr);
1287 EXPECT_EQ(ret, E_OK);
1288
1289 res = store->Execute("DROP TABLE test;", {}, 0);
1290 EXPECT_EQ(res.first, E_OK);
1291 }
1292
1293 /**
1294 * @tc.name: RdbStore_RegisterAlgo_002
1295 * @tc.desc: test RdbStore RegisterAlgo in vector mode
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_P(RdbExecuteRdTest, RdbStore_RegisterAlgo_002, TestSize.Level1)
1299 {
1300 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1301 std::string algoName = "clst_algo_v0";
1302 int ret = store->RegisterAlgo(algoName, ClusterAlgoByEvenNumber);
1303 EXPECT_EQ(ret, E_OK);
1304
1305 std::string sqlCreateTable =
1306 "CREATE TABLE test(id int primary key, repr floatvector(" + std::to_string(CLUSTER_INDEX_DIM) + "));";
1307 std::string sqlCreateIndex =
1308 "CREATE INDEX ivfcluster_l2_idx ON test USING IVFCLUSTER(repr L2) with (CLUSTER_ALGO='clst_algo_v0');";
1309 std::string sqlSelect = "SELECT id, repr, CLUSTER_ID(repr) from test;";
1310
1311 std::pair<int32_t, ValueObject> res = {};
1312 res = store->Execute(sqlCreateTable.c_str(), {});
1313 EXPECT_EQ(res.first, E_OK);
1314
1315 res = store->Execute(sqlCreateIndex.c_str(), {});
1316 EXPECT_EQ(res.first, E_OK);
1317
1318 for (uint16_t i = 0; i < EXPEC_INSERT_CNT_FOR; i++) {
1319 std::string sqlInsert = "INSERT INTO test VALUES(1000000" + std::to_string(i) + ", '" +
1320 GetRandVector(MAX_INT_PART, CLUSTER_INDEX_DIM) + "');";
1321 res = store->Execute(sqlInsert.c_str(), {});
1322 EXPECT_EQ(res.first, E_OK);
1323 }
1324
1325 std::string sqlRunCluster = "PRAGMA CLUSTER_RUN test.ivfcluster_l2_idx;";
1326 res = store->Execute(sqlRunCluster.c_str(), {});
1327 EXPECT_EQ(res.first, E_OK);
1328
1329 std::shared_ptr<ResultSet> resultSet = store->QueryByStep(sqlSelect.c_str(), std::vector<ValueObject>());
1330 EXPECT_NE(resultSet, nullptr);
1331
1332 int32_t resCnt = 0;
1333 while (resultSet->GoToNextRow() == E_OK) {
1334 resCnt++;
1335 }
1336 EXPECT_EQ(EXPEC_INSERT_CNT_FOR, resCnt);
1337
1338 res = store->Execute("DROP TABLE test;", {}, 0);
1339 EXPECT_EQ(res.first, E_OK);
1340 }
1341
1342 /**
1343 * @tc.name: RdbStore_RegisterAlgo_003
1344 * @tc.desc: test sqlite don't support RegisterAlgo
1345 * @tc.type: FUNC
1346 */
1347 HWTEST_P(RdbExecuteRdTest, RdbStore_RegisterAlgo_003, TestSize.Level1)
1348 {
1349 RdbExecuteRdTest::store = nullptr;
1350 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
1351
1352 int errCode = E_OK;
1353 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
1354 RdbStoreConfig config(RdbExecuteRdTest::databaseName);
1355 config.SetIsVector(false);
1356 config.SetEncryptStatus(GetParam());
1357 ExecuteTestOpenRdCallback helper;
1358 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1359 EXPECT_NE(RdbExecuteRdTest::store, nullptr);
1360 EXPECT_EQ(errCode, E_OK);
1361
1362 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1363
1364 std::string sqlCreateTable =
1365 "CREATE TABLE test(id int primary key, repr int);";
1366
1367 std::pair<int32_t, ValueObject> res = {};
1368 res = store->Execute(sqlCreateTable.c_str(), {});
1369 EXPECT_EQ(res.first, E_OK);
1370
1371 std::string algoName = "clst_algo_v0";
1372 int ret = store->RegisterAlgo(algoName, ClusterAlgoByEvenNumber);
1373 EXPECT_EQ(ret, E_NOT_SUPPORT);
1374
1375 res = store->Execute("DROP TABLE test;", {}, 0);
1376 EXPECT_EQ(res.first, E_OK);
1377 }
1378
1379 /**
1380 * @tc.name: RdbStore_RegisterAlgo_004
1381 * @tc.desc: test don't support RegisterAlgo
1382 * @tc.type: FUNC
1383 */
1384 HWTEST_P(RdbExecuteRdTest, RdbStore_RegisterAlgo_004, TestSize.Level1)
1385 {
1386 RdbExecuteRdTest::store = nullptr;
1387 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
1388
1389 int errCode = E_OK;
1390 RdbStoreConfig config(RdbExecuteRdTest::databaseName);
1391 config.SetIsVector(true);
1392 config.SetReadOnly(true);
1393 config.SetEncryptStatus(GetParam());
1394 ExecuteTestOpenRdCallback helper;
1395 RdbExecuteRdTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1396 EXPECT_NE(RdbExecuteRdTest::store, nullptr);
1397 EXPECT_EQ(errCode, E_OK);
1398
1399 std::string algoName = "clst_algo_v0";
1400 int ret = RdbExecuteRdTest::store->RegisterAlgo(algoName, ClusterAlgoByEvenNumber);
1401 EXPECT_EQ(ret, E_NOT_SUPPORT);
1402 }
1403
1404 /**
1405 * @tc.name: RdbStore_RegisterAlgo_005
1406 * @tc.desc: test RegisterAlgo after deleteRdbStore
1407 * @tc.type: FUNC
1408 */
1409 HWTEST_P(RdbExecuteRdTest, RdbStore_RegisterAlgo_005, TestSize.Level1)
1410 {
1411 RdbHelper::DeleteRdbStore(RdbExecuteRdTest::databaseName);
1412 std::shared_ptr<RdbStore> &store = RdbExecuteRdTest::store;
1413 std::string algoName = "clst_algo_v0";
1414 int ret = store->RegisterAlgo(algoName, ClusterAlgoByEvenNumber);
1415 EXPECT_EQ(ret, E_ALREADY_CLOSED);
1416 }
1417