1 /*
2 * Copyright (c) 2022 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 #define LOG_TAG "AbsRdbPredicates"
16 #include "abs_rdb_predicates.h"
17
18 #include <variant>
19
20 #include "logger.h"
21 #include "rdb_trace.h"
22 #include "sqlite_sql_builder.h"
23
24 namespace OHOS::NativeRdb {
25 using namespace OHOS::Rdb;
26
AbsRdbPredicates(const std::string & tableName)27 AbsRdbPredicates::AbsRdbPredicates(const std::string &tableName)
28 {
29 if (tableName.empty()) {
30 tableName_ = "";
31 LOG_DEBUG("No tableName specified.");
32 return;
33 }
34 tableName_ = std::move(tableName);
35 predicates_.tables_.push_back(tableName_);
36 }
37
AbsRdbPredicates(const std::vector<std::string> & tables)38 AbsRdbPredicates::AbsRdbPredicates(const std::vector<std::string> &tables)
39 {
40 if (tables.empty()) {
41 tableName_ = "";
42 LOG_DEBUG("No tableName specified.");
43 return;
44 }
45 tableName_ = *(tables.begin());
46 predicates_.tables_ = std::move(tables);
47 }
48
Clear()49 void AbsRdbPredicates::Clear()
50 {
51 AbsPredicates::Clear();
52 InitialParam();
53 }
54
InitialParam()55 void AbsRdbPredicates::InitialParam()
56 {
57 joinTypes.clear();
58 joinTableNames.clear();
59 joinConditions.clear();
60 joinCount = 0;
61 }
62
GetJoinTypes()63 std::vector<std::string> AbsRdbPredicates::GetJoinTypes()
64 {
65 return joinTypes;
66 }
67
68 /**
69 * Sets the join types in the predicates. The value can be {@code INNER JOIN}, {@code LEFT OUTER JOIN},
70 * and {@code CROSS JOIN}.
71 */
SetJoinTypes(const std::vector<std::string> & joinTypes)72 void AbsRdbPredicates::SetJoinTypes(const std::vector<std::string> &joinTypes)
73 {
74 this->joinTypes = joinTypes;
75 }
76
77 /**
78 * Obtains the database table names of the joins in the predicates.
79 */
GetJoinTableNames()80 std::vector<std::string> AbsRdbPredicates::GetJoinTableNames()
81 {
82 return joinTableNames;
83 }
84
85 /**
86 * Sets the database table names of the joins in the predicates.
87 */
SetJoinTableNames(const std::vector<std::string> & joinTableNames)88 void AbsRdbPredicates::SetJoinTableNames(const std::vector<std::string> &joinTableNames)
89 {
90 this->joinTableNames = joinTableNames;
91 }
92
93 /**
94 * Obtains the join conditions in the predicates.
95 */
GetJoinConditions()96 std::vector<std::string> AbsRdbPredicates::GetJoinConditions()
97 {
98 return joinConditions;
99 }
100
101 /**
102 * Sets the join conditions required in the predicates.
103 */
SetJoinConditions(const std::vector<std::string> & joinConditions)104 void AbsRdbPredicates::SetJoinConditions(const std::vector<std::string> &joinConditions)
105 {
106 this->joinConditions = joinConditions;
107 }
108
109 /**
110 * Obtains the join clause in the predicates.
111 */
GetJoinClause() const112 std::string AbsRdbPredicates::GetJoinClause() const
113 {
114 return "";
115 }
116
117 /**
118 * Obtains the number of joins in the predicates.
119 */
GetJoinCount() const120 int AbsRdbPredicates::GetJoinCount() const
121 {
122 return joinCount;
123 }
124
125 /**
126 * Sets the number of joins in the predicates.
127 */
SetJoinCount(int joinCount)128 void AbsRdbPredicates::SetJoinCount(int joinCount)
129 {
130 this->joinCount = joinCount;
131 }
132
133 /**
134 * Obtains the table name.
135 */
GetTableName() const136 std::string AbsRdbPredicates::GetTableName() const
137 {
138 return tableName_;
139 }
140
ToString() const141 std::string AbsRdbPredicates::ToString() const
142 {
143 std::string args;
144 for (const auto &item : GetWhereArgs()) {
145 args += item + ", ";
146 }
147 return "TableName = " + GetTableName() + ", {WhereClause:" + GetWhereClause() + ", bindArgs:{" + args + "}"
148 + ", order:" + GetOrder() + ", group:" + GetGroup() + ", index:" + GetIndex()
149 + ", limit:" + std::to_string(GetLimit()) + ", offset:" + std::to_string(GetOffset())
150 + ", distinct:" + std::to_string(IsDistinct()) + ", isNeedAnd:" + std::to_string(IsNeedAnd())
151 + ", isSorted:" + std::to_string(IsSorted()) + "}";
152 }
153
InDevices(std::vector<std::string> & devices)154 AbsRdbPredicates *AbsRdbPredicates::InDevices(std::vector<std::string> &devices)
155 {
156 predicates_.devices_ = devices;
157 return this;
158 }
159
InAllDevices()160 AbsRdbPredicates *AbsRdbPredicates::InAllDevices()
161 {
162 predicates_.devices_.clear();
163 return this;
164 }
165
GetDistributedPredicates() const166 const DistributedRdb::PredicatesMemo &AbsRdbPredicates::GetDistributedPredicates() const
167 {
168 int limit = GetLimit();
169 if (limit >= 0) {
170 predicates_.AddOperation(
171 DistributedRdb::RdbPredicateOperator::LIMIT, std::to_string(limit), std::to_string(GetOffset()));
172 }
173 return predicates_;
174 }
175
EqualTo(const std::string & field,const ValueObject & value)176 AbsRdbPredicates *AbsRdbPredicates::EqualTo(const std::string &field, const ValueObject &value)
177 {
178 if (auto pval = std::get_if<std::string>(&value.value)) {
179 predicates_.AddOperation(DistributedRdb::EQUAL_TO, field, *pval);
180 }
181 if (auto pval = std::get_if<ValueObject::Asset>(&value.value)) {
182 predicates_.AddOperation(DistributedRdb::RdbPredicateOperator::ASSETS_ONLY, field, (*pval).name);
183 }
184 if (auto pval = std::get_if<ValueObject::Assets>(&value.value)) {
185 std::vector<std::string> names;
186 for (const auto &asset : *pval) {
187 names.push_back(asset.name);
188 }
189 predicates_.AddOperation(DistributedRdb::RdbPredicateOperator::ASSETS_ONLY, field, names);
190 }
191 return (AbsRdbPredicates *)AbsPredicates::EqualTo(field, value);
192 }
193
NotEqualTo(const std::string & field,const ValueObject & value)194 AbsRdbPredicates *AbsRdbPredicates::NotEqualTo(const std::string &field, const ValueObject &value)
195 {
196 if (auto pval = std::get_if<std::string>(&value.value)) {
197 predicates_.AddOperation(DistributedRdb::NOT_EQUAL_TO, field, *pval);
198 }
199 return (AbsRdbPredicates *)AbsPredicates::NotEqualTo(field, value);
200 }
201
And()202 AbsRdbPredicates *AbsRdbPredicates::And()
203 {
204 predicates_.AddOperation(DistributedRdb::AND, "", "");
205 return (AbsRdbPredicates *)AbsPredicates::And();
206 }
207
Or()208 AbsRdbPredicates *AbsRdbPredicates::Or()
209 {
210 predicates_.AddOperation(DistributedRdb::OR, "", "");
211 return (AbsRdbPredicates *)AbsPredicates::Or();
212 }
213
OrderByAsc(const std::string & field)214 AbsRdbPredicates *AbsRdbPredicates::OrderByAsc(const std::string &field)
215 {
216 std::string isAsc = "true";
217 predicates_.AddOperation(DistributedRdb::ORDER_BY, field, isAsc);
218 return (AbsRdbPredicates *)AbsPredicates::OrderByAsc(field);
219 }
220
OrderByDesc(const std::string & field)221 AbsRdbPredicates *AbsRdbPredicates::OrderByDesc(const std::string &field)
222 {
223 std::string isAsc = "false";
224 predicates_.AddOperation(DistributedRdb::ORDER_BY, field, isAsc);
225 return (AbsRdbPredicates *)AbsPredicates::OrderByDesc(field);
226 }
227
BeginWrap()228 AbsPredicates *AbsRdbPredicates::BeginWrap()
229 {
230 predicates_.AddOperation(DistributedRdb::BEGIN_GROUP, {}, "");
231 return (AbsRdbPredicates *)AbsPredicates::BeginWrap();
232 }
233
EndWrap()234 AbsPredicates *AbsRdbPredicates::EndWrap()
235 {
236 predicates_.AddOperation(DistributedRdb::END_GROUP, {}, "");
237 return (AbsRdbPredicates *)AbsPredicates::EndWrap();
238 }
239
In(const std::string & field,const std::vector<ValueObject> & values)240 AbsPredicates *AbsRdbPredicates::In(const std::string &field, const std::vector<ValueObject> &values)
241 {
242 std::vector<std::string> vals;
243 vals.reserve(values.size());
244 for (const auto &value : values) {
245 auto val = std::get_if<std::string>(&value.value);
246 if (val == nullptr) {
247 return (AbsRdbPredicates *)AbsPredicates::In(field, values);
248 }
249 vals.emplace_back(std::move(*val));
250 }
251 predicates_.AddOperation(DistributedRdb::IN, field, vals);
252 return (AbsRdbPredicates *)AbsPredicates::In(field, values);
253 }
254
In(const std::string & field,const std::vector<std::string> & values)255 AbsPredicates *AbsRdbPredicates::In(const std::string &field, const std::vector<std::string> &values)
256 {
257 predicates_.AddOperation(DistributedRdb::IN, field, values);
258 return (AbsRdbPredicates *)AbsPredicates::In(field, values);
259 }
260
Contains(const std::string & field,const std::string & value)261 AbsRdbPredicates *AbsRdbPredicates::Contains(const std::string &field, const std::string &value)
262 {
263 predicates_.AddOperation(DistributedRdb::CONTAIN, field, value);
264 return (AbsRdbPredicates *)AbsPredicates::Contains(field, value);
265 }
266
NotContains(const std::string & field,const std::string & value)267 AbsRdbPredicates *AbsRdbPredicates::NotContains(const std::string &field, const std::string &value)
268 {
269 predicates_.AddOperation(DistributedRdb::NOT_CONTAINS, field, value);
270 return (AbsRdbPredicates *)AbsPredicates::NotContains(field, value);
271 }
272
BeginsWith(const std::string & field,const std::string & value)273 AbsRdbPredicates *AbsRdbPredicates::BeginsWith(const std::string &field, const std::string &value)
274 {
275 predicates_.AddOperation(DistributedRdb::BEGIN_WITH, field, value);
276 return (AbsRdbPredicates *)AbsPredicates::BeginsWith(field, value);
277 }
EndsWith(const std::string & field,const std::string & value)278 AbsRdbPredicates *AbsRdbPredicates::EndsWith(const std::string &field, const std::string &value)
279 {
280 predicates_.AddOperation(DistributedRdb::END_WITH, field, value);
281 return (AbsRdbPredicates *)AbsPredicates::EndsWith(field, value);
282 }
IsNull(const std::string & field)283 AbsRdbPredicates *AbsRdbPredicates::IsNull(const std::string &field)
284 {
285 predicates_.AddOperation(DistributedRdb::IS_NULL, field, "");
286 return (AbsRdbPredicates *)AbsPredicates::IsNull(field);
287 }
IsNotNull(const std::string & field)288 AbsRdbPredicates *AbsRdbPredicates::IsNotNull(const std::string &field)
289 {
290 predicates_.AddOperation(DistributedRdb::IS_NOT_NULL, field, "");
291 return (AbsRdbPredicates *)AbsPredicates::IsNotNull(field);
292 }
Like(const std::string & field,const std::string & value)293 AbsRdbPredicates *AbsRdbPredicates::Like(const std::string &field, const std::string &value)
294 {
295 predicates_.AddOperation(DistributedRdb::LIKE, field, value);
296 return (AbsRdbPredicates *)AbsPredicates::Like(field, value);
297 }
NotLike(const std::string & field,const std::string & value)298 AbsRdbPredicates *AbsRdbPredicates::NotLike(const std::string &field, const std::string &value)
299 {
300 predicates_.AddOperation(DistributedRdb::NOT_LIKE, field, value);
301 return (AbsRdbPredicates *)AbsPredicates::NotLike(field, value);
302 }
Glob(const std::string & field,const std::string & value)303 AbsRdbPredicates *AbsRdbPredicates::Glob(const std::string &field, const std::string &value)
304 {
305 predicates_.AddOperation(DistributedRdb::GLOB, field, value);
306 return (AbsRdbPredicates *)AbsPredicates::Glob(field, value);
307 }
NotGlob(const std::string & field,const std::string & value)308 AbsRdbPredicates *AbsRdbPredicates::NotGlob(const std::string &field, const std::string &value)
309 {
310 predicates_.AddOperation(DistributedRdb::NOT_GLOB, field, value);
311 return (AbsRdbPredicates *)AbsPredicates::NotGlob(field, value);
312 }
Distinct()313 AbsRdbPredicates *AbsRdbPredicates::Distinct()
314 {
315 predicates_.AddOperation(DistributedRdb::DISTINCT, "", "");
316 return (AbsRdbPredicates *)AbsPredicates::Distinct();
317 }
IndexedBy(const std::string & indexName)318 AbsRdbPredicates *AbsRdbPredicates::IndexedBy(const std::string &indexName)
319 {
320 predicates_.AddOperation(DistributedRdb::INDEXED_BY, indexName, "");
321 return (AbsRdbPredicates *)AbsPredicates::IndexedBy(indexName);
322 }
NotIn(const std::string & field,const std::vector<std::string> & values)323 AbsRdbPredicates *AbsRdbPredicates::NotIn(const std::string &field, const std::vector<std::string> &values)
324 {
325 predicates_.AddOperation(DistributedRdb::NOT_IN, field, values);
326 return (AbsRdbPredicates *)AbsPredicates::NotIn(field, values);
327 }
NotIn(const std::string & field,const std::vector<ValueObject> & values)328 AbsRdbPredicates *AbsRdbPredicates::NotIn(const std::string &field, const std::vector<ValueObject> &values)
329 {
330 std::vector<std::string> vals;
331 vals.reserve(values.size());
332 for (const auto &value : values) {
333 auto val = std::get_if<std::string>(&value.value);
334 if (val == nullptr) {
335 return (AbsRdbPredicates *)AbsPredicates::NotIn(field, values);
336 }
337 vals.emplace_back(std::move(*val));
338 }
339 predicates_.AddOperation(DistributedRdb::NOT_IN, field, vals);
340 return (AbsRdbPredicates *)AbsPredicates::NotIn(field, values);
341 }
GetStatement() const342 std::string AbsRdbPredicates::GetStatement() const
343 {
344 return SqliteSqlBuilder::BuildClauseFromPredicates(*this);
345 }
346 } // namespace OHOS::NativeRdb