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
16 #define LOG_TAG "RdbResultSetImpl"
17
18 #include "log_print.h"
19 #include "rdb_errno.h"
20 #include "store_types.h"
21 #include "rdb_result_set_impl.h"
22
23 using DistributedDB::DBStatus;
24 using OHOS::NativeRdb::ColumnType;
25
26 namespace OHOS::DistributedRdb {
RdbResultSetImpl(std::shared_ptr<DistributedDB::ResultSet> & resultSet)27 RdbResultSetImpl::RdbResultSetImpl(std::shared_ptr<DistributedDB::ResultSet> &resultSet) : resultSet_(resultSet)
28 {
29 }
30
GetAllColumnNames(std::vector<std::string> & columnNames)31 int RdbResultSetImpl::GetAllColumnNames(std::vector<std::string> &columnNames)
32 {
33 std::shared_lock<std::shared_mutex> lock(this->mutex_);
34 if (resultSet_ == nullptr) {
35 ZLOGE("DistributedDB resultSet is null.");
36 return NativeRdb::E_ERROR;
37 }
38 resultSet_->GetColumnNames(columnNames);
39 return NativeRdb::E_OK;
40 }
41
GetColumnCount(int & count)42 int RdbResultSetImpl::GetColumnCount(int &count)
43 {
44 return NativeRdb::E_NOT_SUPPORT;
45 }
46
GetColumnType(int columnIndex,ColumnType & columnType)47 int RdbResultSetImpl::GetColumnType(int columnIndex, ColumnType &columnType)
48 {
49 std::shared_lock<std::shared_mutex> lock(this->mutex_);
50 if (resultSet_ == nullptr) {
51 ZLOGE("DistributedDB resultSet is null.");
52 return NativeRdb::E_ERROR;
53 }
54 DbColumnType dbColumnType;
55 DBStatus status = resultSet_->GetColumnType(columnIndex, dbColumnType);
56 if (status != DBStatus::OK) {
57 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
58 return NativeRdb::E_ERROR;
59 }
60 columnType = ConvertColumnType(dbColumnType);
61 return NativeRdb::E_OK;
62 }
63
GetColumnIndex(const std::string & columnName,int & columnIndex)64 int RdbResultSetImpl::GetColumnIndex(const std::string &columnName, int &columnIndex)
65 {
66 std::shared_lock<std::shared_mutex> lock(this->mutex_);
67 if (resultSet_ == nullptr) {
68 ZLOGE("DistributedDB resultSet is null.");
69 return NativeRdb::E_ERROR;
70 }
71 DBStatus status = resultSet_->GetColumnIndex(columnName, columnIndex);
72 if (status != DBStatus::OK) {
73 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
74 return NativeRdb::E_ERROR;
75 }
76 return NativeRdb::E_OK;
77 }
78
GetColumnName(int columnIndex,std::string & columnName)79 int RdbResultSetImpl::GetColumnName(int columnIndex, std::string &columnName)
80 {
81 std::shared_lock<std::shared_mutex> lock(this->mutex_);
82 if (resultSet_ == nullptr) {
83 ZLOGE("DistributedDB resultSet is null.");
84 return NativeRdb::E_ERROR;
85 }
86 DBStatus status = resultSet_->GetColumnName(columnIndex, columnName);
87 if (status != DBStatus::OK) {
88 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
89 return NativeRdb::E_ERROR;
90 }
91 return NativeRdb::E_OK;
92 }
93
GetRowCount(int & count)94 int RdbResultSetImpl::GetRowCount(int &count)
95 {
96 std::shared_lock<std::shared_mutex> lock(this->mutex_);
97 if (resultSet_ == nullptr) {
98 ZLOGE("DistributedDB resultSet is null.");
99 return NativeRdb::E_ERROR;
100 }
101 count = resultSet_->GetCount();
102 return NativeRdb::E_OK;
103 }
104
GetRowIndex(int & position) const105 int RdbResultSetImpl::GetRowIndex(int &position) const
106 {
107 std::shared_lock<std::shared_mutex> lock(this->mutex_);
108 if (resultSet_ == nullptr) {
109 ZLOGE("DistributedDB resultSet is null.");
110 return NativeRdb::E_ERROR;
111 }
112 position = resultSet_->GetPosition();
113 return NativeRdb::E_OK;
114 }
115
GoTo(int offset)116 int RdbResultSetImpl::GoTo(int offset)
117 {
118 std::shared_lock<std::shared_mutex> lock(this->mutex_);
119 if (resultSet_ == nullptr) {
120 ZLOGE("DistributedDB resultSet is null.");
121 return NativeRdb::E_ERROR;
122 }
123 if (!resultSet_->Move(offset)) {
124 ZLOGE("DistributedDB resultSet operate failed.");
125 return NativeRdb::E_ERROR;
126 }
127 return NativeRdb::E_OK;
128 }
129
GoToRow(int position)130 int RdbResultSetImpl::GoToRow(int position)
131 {
132 std::shared_lock<std::shared_mutex> lock(this->mutex_);
133 if (resultSet_ == nullptr) {
134 ZLOGE("DistributedDB resultSet is null.");
135 return NativeRdb::E_ERROR;
136 }
137 if (!resultSet_->MoveToPosition(position)) {
138 ZLOGE("DistributedDB resultSet operate failed.");
139 return NativeRdb::E_ERROR;
140 }
141 return NativeRdb::E_OK;
142 }
143
GoToFirstRow()144 int RdbResultSetImpl::GoToFirstRow()
145 {
146 std::shared_lock<std::shared_mutex> lock(this->mutex_);
147 if (resultSet_ == nullptr) {
148 ZLOGE("DistributedDB resultSet is null.");
149 return NativeRdb::E_ERROR;
150 }
151 if (!resultSet_->MoveToFirst()) {
152 ZLOGE("DistributedDB resultSet operate failed.");
153 return NativeRdb::E_ERROR;
154 }
155 return NativeRdb::E_OK;
156 }
157
GoToLastRow()158 int RdbResultSetImpl::GoToLastRow()
159 {
160 std::shared_lock<std::shared_mutex> lock(this->mutex_);
161 if (resultSet_ == nullptr) {
162 ZLOGE("DistributedDB resultSet is null.");
163 return NativeRdb::E_ERROR;
164 }
165 if (!resultSet_->MoveToLast()) {
166 ZLOGE("DistributedDB resultSet operate failed.");
167 return NativeRdb::E_ERROR;
168 }
169 return NativeRdb::E_OK;
170 }
171
GoToNextRow()172 int RdbResultSetImpl::GoToNextRow()
173 {
174 std::shared_lock<std::shared_mutex> lock(this->mutex_);
175 if (resultSet_ == nullptr) {
176 ZLOGE("DistributedDB resultSet is null.");
177 return NativeRdb::E_ERROR;
178 }
179 if (!resultSet_->MoveToNext()) {
180 ZLOGE("DistributedDB resultSet operate failed.");
181 return NativeRdb::E_ERROR;
182 }
183 return NativeRdb::E_OK;
184 }
185
GoToPreviousRow()186 int RdbResultSetImpl::GoToPreviousRow()
187 {
188 std::shared_lock<std::shared_mutex> lock(this->mutex_);
189 if (resultSet_ == nullptr) {
190 ZLOGE("DistributedDB resultSet is null.");
191 return NativeRdb::E_ERROR;
192 }
193 if (!resultSet_->MoveToPrevious()) {
194 ZLOGE("DistributedDB resultSet operate failed.");
195 return NativeRdb::E_ERROR;
196 }
197 return NativeRdb::E_OK;
198 }
199
IsEnded(bool & result)200 int RdbResultSetImpl::IsEnded(bool &result)
201 {
202 std::shared_lock<std::shared_mutex> lock(this->mutex_);
203 if (resultSet_ == nullptr) {
204 ZLOGE("DistributedDB resultSet is null.");
205 return NativeRdb::E_ERROR;
206 }
207 result = resultSet_->IsAfterLast();
208 return NativeRdb::E_OK;
209 }
210
IsStarted(bool & result) const211 int RdbResultSetImpl::IsStarted(bool &result) const
212 {
213 std::shared_lock<std::shared_mutex> lock(this->mutex_);
214 if (resultSet_ == nullptr) {
215 ZLOGE("DistributedDB resultSet is null.");
216 return NativeRdb::E_ERROR;
217 }
218 result = resultSet_->IsBeforeFirst();
219 return NativeRdb::E_OK;
220 }
221
IsAtFirstRow(bool & result) const222 int RdbResultSetImpl::IsAtFirstRow(bool &result) const
223 {
224 std::shared_lock<std::shared_mutex> lock(this->mutex_);
225 if (resultSet_ == nullptr) {
226 ZLOGE("DistributedDB resultSet is null.");
227 return NativeRdb::E_ERROR;
228 }
229 result = resultSet_->IsFirst();
230 return NativeRdb::E_OK;
231 }
232
IsAtLastRow(bool & result)233 int RdbResultSetImpl::IsAtLastRow(bool &result)
234 {
235 std::shared_lock<std::shared_mutex> lock(this->mutex_);
236 if (resultSet_ == nullptr) {
237 ZLOGE("DistributedDB resultSet is null.");
238 return NativeRdb::E_ERROR;
239 }
240 result = resultSet_->IsLast();
241 return NativeRdb::E_OK;
242 }
243
GetBlob(int columnIndex,std::vector<uint8_t> & blob)244 int RdbResultSetImpl::GetBlob(int columnIndex, std::vector<uint8_t> &blob)
245 {
246 std::shared_lock<std::shared_mutex> lock(this->mutex_);
247 if (resultSet_ == nullptr) {
248 ZLOGE("DistributedDB resultSet is null.");
249 return NativeRdb::E_ERROR;
250 }
251 DBStatus status = resultSet_->Get(columnIndex, blob);
252 if (status != DBStatus::OK) {
253 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
254 return NativeRdb::E_ERROR;
255 }
256 return NativeRdb::E_OK;
257 }
258
GetString(int columnIndex,std::string & value)259 int RdbResultSetImpl::GetString(int columnIndex, std::string &value)
260 {
261 std::shared_lock<std::shared_mutex> lock(this->mutex_);
262 if (resultSet_ == nullptr) {
263 ZLOGE("DistributedDB resultSet is null.");
264 return NativeRdb::E_ERROR;
265 }
266 DBStatus status = resultSet_->Get(columnIndex, value);
267 if (status != DBStatus::OK) {
268 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
269 return NativeRdb::E_ERROR;
270 }
271 return NativeRdb::E_OK;
272 }
273
GetInt(int columnIndex,int & value)274 int RdbResultSetImpl::GetInt(int columnIndex, int &value)
275 {
276 return NativeRdb::E_NOT_SUPPORT;
277 }
278
GetLong(int columnIndex,int64_t & value)279 int RdbResultSetImpl::GetLong(int columnIndex, int64_t &value)
280 {
281 std::shared_lock<std::shared_mutex> lock(this->mutex_);
282 if (resultSet_ == nullptr) {
283 ZLOGE("DistributedDB resultSet is null.");
284 return NativeRdb::E_ERROR;
285 }
286 DBStatus status = resultSet_->Get(columnIndex, value);
287 if (status != DBStatus::OK) {
288 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
289 return NativeRdb::E_ERROR;
290 }
291 return NativeRdb::E_OK;
292 }
293
GetDouble(int columnIndex,double & value)294 int RdbResultSetImpl::GetDouble(int columnIndex, double &value)
295 {
296 std::shared_lock<std::shared_mutex> lock(this->mutex_);
297 if (resultSet_ == nullptr) {
298 ZLOGE("DistributedDB resultSet is null.");
299 return NativeRdb::E_ERROR;
300 }
301 DBStatus status = resultSet_->Get(columnIndex, value);
302 if (status != DBStatus::OK) {
303 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
304 return NativeRdb::E_ERROR;
305 }
306 return NativeRdb::E_OK;
307 }
308
IsColumnNull(int columnIndex,bool & isNull)309 int RdbResultSetImpl::IsColumnNull(int columnIndex, bool &isNull)
310 {
311 std::shared_lock<std::shared_mutex> lock(this->mutex_);
312 if (resultSet_ == nullptr) {
313 ZLOGE("DistributedDB resultSet is null.");
314 return NativeRdb::E_ERROR;
315 }
316 DBStatus status = resultSet_->IsColumnNull(columnIndex, isNull);
317 if (status != DBStatus::OK) {
318 ZLOGE("DistributedDB resultSet operate failed, status is %{public}d.", status);
319 return NativeRdb::E_ERROR;
320 }
321 return NativeRdb::E_OK;
322 }
323
IsClosed() const324 bool RdbResultSetImpl::IsClosed() const
325 {
326 std::shared_lock<std::shared_mutex> lock(this->mutex_);
327 if (resultSet_ == nullptr) {
328 ZLOGE("DistributedDB resultSet is null.");
329 return true;
330 }
331 return resultSet_->IsClosed();
332 }
333
Close()334 int RdbResultSetImpl::Close()
335 {
336 std::unique_lock<std::shared_mutex> lock(this->mutex_);
337 if (resultSet_ == nullptr) {
338 ZLOGE("Result set has been closed.");
339 return NativeRdb::E_OK;
340 }
341 resultSet_->Close();
342 resultSet_ = nullptr;
343 return NativeRdb::E_OK;
344 }
345
ConvertColumnType(DbColumnType columnType) const346 ColumnType RdbResultSetImpl::ConvertColumnType(DbColumnType columnType) const
347 {
348 switch (columnType) {
349 case DbColumnType::INT64:
350 return ColumnType::TYPE_INTEGER;
351 case DbColumnType::STRING:
352 return ColumnType::TYPE_STRING;
353 case DbColumnType::BLOB:
354 return ColumnType::TYPE_BLOB;
355 case DbColumnType::DOUBLE:
356 return ColumnType::TYPE_FLOAT;
357 case DbColumnType::NULL_VALUE:
358 return ColumnType::TYPE_NULL;
359 default:
360 return ColumnType::TYPE_NULL;
361 }
362 }
363 }
364