1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "rdb_general_ut.h"
17 #include "relational_store_client.h"
18
19 using namespace testing::ext;
20 using namespace DistributedDB;
21 using namespace DistributedDBUnitTest;
22
23 namespace {
24 class DistributedDBRDBKnowledgeTest : public RDBGeneralUt {
25 public:
26 void SetUp() override;
27 protected:
28 static UtDateBaseSchemaInfo GetDefaultSchema();
29 static UtTableSchemaInfo GetTableSchema(const std::string &table);
30 static KnowledgeSourceSchema GetKnowledgeSchema();
31 static constexpr const char *KNOWLEDGE_TABLE = "KNOWLEDGE_TABLE";
32 static constexpr const char *SYNC_TABLE = "SYNC_TABLE";
33 StoreInfo info1_ = {USER_ID, APP_ID, STORE_ID_1};
34 };
35
SetUp()36 void DistributedDBRDBKnowledgeTest::SetUp()
37 {
38 RDBGeneralUt::SetUp();
39 SetSchemaInfo(info1_, GetDefaultSchema());
40 InitDatabase(info1_);
41 }
42
GetDefaultSchema()43 UtDateBaseSchemaInfo DistributedDBRDBKnowledgeTest::GetDefaultSchema()
44 {
45 UtDateBaseSchemaInfo info;
46 info.tablesInfo.push_back(GetTableSchema(KNOWLEDGE_TABLE));
47 return info;
48 }
49
GetTableSchema(const std::string & table)50 UtTableSchemaInfo DistributedDBRDBKnowledgeTest::GetTableSchema(const std::string &table)
51 {
52 UtTableSchemaInfo tableSchema;
53 tableSchema.name = table;
54 UtFieldInfo field;
55 field.field.colName = "id";
56 field.field.type = TYPE_INDEX<int64_t>;
57 field.field.primary = true;
58 tableSchema.fieldInfo.push_back(field);
59 field.field.primary = false;
60 field.field.colName = "int_field1";
61 tableSchema.fieldInfo.push_back(field);
62 field.field.colName = "int_field2";
63 tableSchema.fieldInfo.push_back(field);
64 field.field.colName = "int_field3";
65 tableSchema.fieldInfo.push_back(field);
66 return tableSchema;
67 }
68
GetKnowledgeSchema()69 KnowledgeSourceSchema DistributedDBRDBKnowledgeTest::GetKnowledgeSchema()
70 {
71 KnowledgeSourceSchema schema;
72 schema.extendColNames.insert("id");
73 schema.knowledgeColNames.insert("int_field1");
74 schema.knowledgeColNames.insert("int_field2");
75 schema.tableName = SYNC_TABLE;
76 return schema;
77 }
78
79 /**
80 * @tc.name: SetKnowledge001
81 * @tc.desc: Test set knowledge schema.
82 * @tc.type: FUNC
83 * @tc.require:
84 * @tc.author: zqq
85 */
86 HWTEST_F(DistributedDBRDBKnowledgeTest, SetKnowledge001, TestSize.Level0)
87 {
88 /**
89 * @tc.steps: step1. Set knowledge source schema and clean deleted data.
90 * @tc.expected: step1. Ok
91 */
92 auto db = GetSqliteHandle(info1_);
93 ASSERT_NE(db, nullptr);
94 KnowledgeSourceSchema schema;
95 schema.tableName = KNOWLEDGE_TABLE;
96 schema.extendColNames.insert("id");
97 schema.knowledgeColNames.insert("int_field1");
98 schema.knowledgeColNames.insert("int_field2");
99 EXPECT_EQ(SetKnowledgeSourceSchema(db, schema), OK);
100 EXPECT_EQ(CleanDeletedData(db, schema.tableName, 0u), OK);
101 /**
102 * @tc.steps: step2. Clean deleted data after insert one data.
103 * @tc.expected: step2. Ok
104 */
105 EXPECT_EQ(InsertLocalDBData(0, 1, info1_), E_OK);
106 EXPECT_EQ(CleanDeletedData(db, schema.tableName, 0u), OK);
107 /**
108 * @tc.steps: step3. Clean deleted data after delete one data.
109 * @tc.expected: step3. Ok
110 */
111 std::string sql = std::string("DELETE FROM ").append(KNOWLEDGE_TABLE).append(" WHERE 1=1");
112 EXPECT_EQ(SQLiteUtils::ExecuteRawSQL(db, sql), E_OK);
113 EXPECT_EQ(CleanDeletedData(db, schema.tableName, 10u), OK); // delete which cursor less than 10
114 }
115
116 /**
117 * @tc.name: SetKnowledge002
118 * @tc.desc: Test set knowledge schema with invalid args.
119 * @tc.type: FUNC
120 * @tc.require:
121 * @tc.author: zqq
122 */
123 HWTEST_F(DistributedDBRDBKnowledgeTest, SetKnowledge002, TestSize.Level0)
124 {
125 /**
126 * @tc.steps: step1. Set knowledge source schema and clean deleted data with null db.
127 * @tc.expected: step1. INVALID_ARGS
128 */
129 KnowledgeSourceSchema schema;
130 schema.tableName = KNOWLEDGE_TABLE;
131 schema.extendColNames.insert("id");
132 schema.knowledgeColNames.insert("int_field1");
133 schema.knowledgeColNames.insert("int_field2");
134 EXPECT_EQ(SetKnowledgeSourceSchema(nullptr, schema), INVALID_ARGS);
135 EXPECT_EQ(CleanDeletedData(nullptr, schema.tableName, 0u), INVALID_ARGS);
136 /**
137 * @tc.steps: step2. Set knowledge source schema and clean deleted data with null db.
138 * @tc.expected: step2. INVALID_ARGS
139 */
140 auto db = GetSqliteHandle(info1_);
141 ASSERT_NE(db, nullptr);
142 schema.tableName = "UNKNOWN_TABLE";
143 EXPECT_EQ(SetKnowledgeSourceSchema(db, schema), INVALID_ARGS);
144 EXPECT_EQ(CleanDeletedData(db, schema.tableName, 0u), OK);
145 }
146
147 /**
148 * @tc.name: SetKnowledge003
149 * @tc.desc: Test set knowledge schema after create distributed table.
150 * @tc.type: FUNC
151 * @tc.require:
152 * @tc.author: zqq
153 */
154 HWTEST_F(DistributedDBRDBKnowledgeTest, SetKnowledge003, TestSize.Level0)
155 {
156 /**
157 * @tc.steps: step1. Create distributed table.
158 * @tc.expected: step1. Ok
159 */
160 UtDateBaseSchemaInfo info;
161 info.tablesInfo.push_back(GetTableSchema(KNOWLEDGE_TABLE));
162 info.tablesInfo.push_back(GetTableSchema(SYNC_TABLE));
163 SetSchemaInfo(info1_, info);
164 ASSERT_EQ(DistributedDB::RDBGeneralUt::InitDelegate(info1_), E_OK);
165 ASSERT_EQ(CreateDistributedTable(info1_, SYNC_TABLE), E_OK);
166 /**
167 * @tc.steps: step2. Set knowledge source schema.
168 * @tc.expected: step2. INVALID_ARGS
169 */
170 auto db = GetSqliteHandle(info1_);
171 ASSERT_NE(db, nullptr);
172 EXPECT_EQ(SetKnowledgeSourceSchema(db, GetKnowledgeSchema()), INVALID_ARGS);
173 }
174
175 /**
176 * @tc.name: SetKnowledge004
177 * @tc.desc: Test set knowledge schema after create tracker table.
178 * @tc.type: FUNC
179 * @tc.require:
180 * @tc.author: zqq
181 */
182 HWTEST_F(DistributedDBRDBKnowledgeTest, SetKnowledge004, TestSize.Level0)
183 {
184 /**
185 * @tc.steps: step1. Create tracker table.
186 * @tc.expected: step1. Ok
187 */
188 UtDateBaseSchemaInfo info;
189 info.tablesInfo.push_back(GetTableSchema(SYNC_TABLE));
190 info.tablesInfo.push_back(GetTableSchema(KNOWLEDGE_TABLE));
191 SetSchemaInfo(info1_, info);
192 ASSERT_EQ(DistributedDB::RDBGeneralUt::InitDelegate(info1_), E_OK);
193 ASSERT_EQ(DistributedDB::RDBGeneralUt::SetTrackerTables(info1_, {SYNC_TABLE}), E_OK);
194 /**
195 * @tc.steps: step2. Set knowledge source schema.
196 * @tc.expected: step2. INVALID_ARGS
197 */
198 auto db = GetSqliteHandle(info1_);
199 ASSERT_NE(db, nullptr);
200 EXPECT_EQ(SetKnowledgeSourceSchema(db, GetKnowledgeSchema()), INVALID_ARGS);
201 }
202
203 /**
204 * @tc.name: SetKnowledge005
205 * @tc.desc: Test set knowledge schema and then drop table.
206 * @tc.type: FUNC
207 * @tc.require:
208 * @tc.author: suyuchen
209 */
210 HWTEST_F(DistributedDBRDBKnowledgeTest, SetKnowledge005, TestSize.Level0)
211 {
212 /**
213 * @tc.steps: step1. Set knowledge source schema and clean deleted data.
214 * @tc.expected: step1. Ok
215 */
216 auto db = GetSqliteHandle(info1_);
217 ASSERT_NE(db, nullptr);
218 KnowledgeSourceSchema schema;
219 schema.tableName = KNOWLEDGE_TABLE;
220 schema.extendColNames.insert("id");
221 schema.knowledgeColNames.insert("int_field1");
222 schema.knowledgeColNames.insert("int_field2");
223 EXPECT_EQ(SetKnowledgeSourceSchema(db, schema), OK);
224
225 /**
226 * @tc.steps: step2. Create inverted table.
227 * @tc.expected: step2. ok
228 */
229 std::string inverted = std::string(KNOWLEDGE_TABLE) + "_inverted";
230 std::string sql = "CREATE VIRTUAL TABLE IF NOT EXISTS " + inverted + " USING fts3(col1, col2);";
231 EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), SQLITE_OK);
232
233 sql = "SELECT count(*) FROM " + inverted + ";";
234 EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), SQLITE_OK);
235
236 /**
237 * @tc.steps: step3. Drop knowledge table.
238 * @tc.expected: step3. ok
239 */
240 sql = "DROP TABLE IF EXISTS " + std::string(KNOWLEDGE_TABLE) + ";";
241 EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), SQLITE_OK);
242
243 /**
244 * @tc.steps: step4. Inverted table not exist.
245 * @tc.expected: step4. ok
246 */
247 sql = "SELECT count(*) FROM " + inverted + ";";
248 EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), SQLITE_ERROR);
249 }
250 }