• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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