1 /*
2 * Copyright (c) 2021 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 "sqlite_single_ver_storage_executor.h"
17
18 #include <algorithm>
19
20 #include "log_print.h"
21 #include "db_constant.h"
22 #include "db_common.h"
23 #include "db_errno.h"
24 #include "parcel.h"
25 #include "platform_specific.h"
26 #include "runtime_context.h"
27 #include "sqlite_single_ver_storage_executor_sql.h"
28
29 namespace DistributedDB {
30 namespace {
InitCommitNotifyDataKeyStatus(SingleVerNaturalStoreCommitNotifyData * committedData,const Key & hashKey,const DataOperStatus & dataStatus)31 void InitCommitNotifyDataKeyStatus(SingleVerNaturalStoreCommitNotifyData *committedData, const Key &hashKey,
32 const DataOperStatus &dataStatus)
33 {
34 if (committedData == nullptr) {
35 return;
36 }
37
38 ExistStatus existedStatus = ExistStatus::NONE;
39 if (dataStatus.preStatus == DataStatus::DELETED) {
40 existedStatus = ExistStatus::DELETED;
41 } else if (dataStatus.preStatus == DataStatus::EXISTED) {
42 existedStatus = ExistStatus::EXIST;
43 }
44
45 committedData->InitKeyPropRecord(hashKey, existedStatus);
46 }
47
ResetOrRegetStmt(sqlite3 * db,sqlite3_stmt * & stmt,const std::string & sql)48 int ResetOrRegetStmt(sqlite3 *db, sqlite3_stmt *&stmt, const std::string &sql)
49 {
50 int errCode = E_OK;
51 SQLiteUtils::ResetStatement(stmt, false, errCode);
52 if (errCode != E_OK) {
53 LOGE("[ResetOrRegetStmt] reset stmt failed:%d.", errCode);
54 // Finish current statement and remade one
55 SQLiteUtils::ResetStatement(stmt, true, errCode);
56 errCode = SQLiteUtils::GetStatement(db, sql, stmt);
57 if (errCode != E_OK) {
58 LOGE("[ResetOrRegetStmt] reget failed:%d.", errCode);
59 }
60 }
61 return errCode;
62 }
63 }
64
SQLiteSingleVerStorageExecutor(sqlite3 * dbHandle,bool writable,bool isMemDb)65 SQLiteSingleVerStorageExecutor::SQLiteSingleVerStorageExecutor(sqlite3 *dbHandle, bool writable, bool isMemDb)
66 : SQLiteStorageExecutor(dbHandle, writable, isMemDb),
67 getSyncStatement_(nullptr),
68 getResultRowIdStatement_(nullptr),
69 getResultEntryStatement_(nullptr),
70 isTransactionOpen_(false),
71 attachMetaMode_(false),
72 executorState_(ExecutorState::INVALID),
73 maxTimestampInMainDB_(0),
74 migrateTimeOffset_(0),
75 isSyncMigrating_(false),
76 conflictResolvePolicy_(DEFAULT_LAST_WIN)
77 {}
78
SQLiteSingleVerStorageExecutor(sqlite3 * dbHandle,bool writable,bool isMemDb,ExecutorState executorState)79 SQLiteSingleVerStorageExecutor::SQLiteSingleVerStorageExecutor(sqlite3 *dbHandle, bool writable, bool isMemDb,
80 ExecutorState executorState)
81 : SQLiteStorageExecutor(dbHandle, writable, isMemDb),
82 getSyncStatement_(nullptr),
83 getResultRowIdStatement_(nullptr),
84 getResultEntryStatement_(nullptr),
85 isTransactionOpen_(false),
86 attachMetaMode_(false),
87 executorState_(executorState),
88 maxTimestampInMainDB_(0),
89 migrateTimeOffset_(0),
90 isSyncMigrating_(false),
91 conflictResolvePolicy_(DEFAULT_LAST_WIN)
92 {}
93
~SQLiteSingleVerStorageExecutor()94 SQLiteSingleVerStorageExecutor::~SQLiteSingleVerStorageExecutor()
95 {
96 if (isTransactionOpen_) {
97 Rollback();
98 }
99 FinalizeAllStatements();
100 }
101
GetKvData(SingleVerDataType type,const Key & key,Value & value,Timestamp & timestamp) const102 int SQLiteSingleVerStorageExecutor::GetKvData(SingleVerDataType type, const Key &key, Value &value,
103 Timestamp ×tamp) const
104 {
105 std::string sql;
106 if (type == SingleVerDataType::LOCAL_TYPE) {
107 sql = SELECT_LOCAL_VALUE_TIMESTAMP_SQL;
108 } else if (type == SingleVerDataType::SYNC_TYPE) {
109 sql = SELECT_SYNC_VALUE_WTIMESTAMP_SQL;
110 } else if (type == SingleVerDataType::META_TYPE) {
111 if (attachMetaMode_) {
112 sql = SELECT_ATTACH_META_VALUE_SQL;
113 } else {
114 sql = SELECT_META_VALUE_SQL;
115 }
116 } else {
117 return -E_INVALID_ARGS;
118 }
119
120 sqlite3_stmt *statement = nullptr;
121 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
122 if (errCode != E_OK) {
123 goto END;
124 }
125
126 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, key, false); // first arg.
127 if (errCode != E_OK) {
128 goto END;
129 }
130
131 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
132 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
133 errCode = -E_NOT_FOUND;
134 goto END;
135 } else if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
136 goto END;
137 }
138
139 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, value); // only one result.
140
141 // get timestamp
142 if (type == SingleVerDataType::LOCAL_TYPE) {
143 timestamp = static_cast<Timestamp>(sqlite3_column_int64(statement, GET_KV_RES_LOCAL_TIME_INDEX));
144 } else if (type == SingleVerDataType::SYNC_TYPE) {
145 timestamp = static_cast<Timestamp>(sqlite3_column_int64(statement, GET_KV_RES_SYNC_TIME_INDEX));
146 }
147
148 END:
149 SQLiteUtils::ResetStatement(statement, true, errCode);
150 return CheckCorruptedStatus(errCode);
151 }
152
BindPutKvData(sqlite3_stmt * statement,const Key & key,const Value & value,Timestamp timestamp,SingleVerDataType type)153 int SQLiteSingleVerStorageExecutor::BindPutKvData(sqlite3_stmt *statement, const Key &key, const Value &value,
154 Timestamp timestamp, SingleVerDataType type)
155 {
156 int errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_KV_KEY_INDEX, key, false);
157 if (errCode != E_OK) {
158 LOGE("[SingleVerExe][BindPutKv]Bind key error:%d", errCode);
159 return errCode;
160 }
161
162 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_KV_VAL_INDEX, value, true);
163 if (errCode != E_OK) {
164 LOGE("[SingleVerExe][BindPutKv]Bind value error:%d", errCode);
165 return errCode;
166 }
167
168 if (type == SingleVerDataType::LOCAL_TYPE) {
169 Key hashKey;
170 errCode = DBCommon::CalcValueHash(key, hashKey);
171 if (errCode != E_OK) {
172 return errCode;
173 }
174
175 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_LOCAL_HASH_KEY_INDEX, hashKey, false);
176 if (errCode != E_OK) {
177 LOGE("[SingleVerExe][BindPutKv]Bind hash key error:%d", errCode);
178 return errCode;
179 }
180
181 errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_LOCAL_TIMESTAMP_INDEX, timestamp);
182 if (errCode != E_OK) {
183 LOGE("[SingleVerExe][BindPutKv]Bind timestamp error:%d", errCode);
184 return errCode;
185 }
186 }
187 return E_OK;
188 }
189
GetKvDataByHashKey(const Key & hashKey,SingleVerRecord & result) const190 int SQLiteSingleVerStorageExecutor::GetKvDataByHashKey(const Key &hashKey, SingleVerRecord &result) const
191 {
192 sqlite3_stmt *statement = nullptr;
193 std::vector<uint8_t> devVect;
194 std::vector<uint8_t> origDevVect;
195 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_HASH_SQL, statement);
196 if (errCode != E_OK) {
197 goto END;
198 }
199
200 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, hashKey, false); // bind the first arg hashkey.
201 if (errCode != E_OK) {
202 goto END;
203 }
204
205 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
206 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
207 result.hashKey = hashKey;
208 result.timestamp = static_cast<Timestamp>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
209 result.writeTimestamp = static_cast<Timestamp>(sqlite3_column_int64(statement, SYNC_RES_W_TIME_INDEX));
210 result.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
211 // get key
212 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, result.key);
213 if (errCode != E_OK) {
214 goto END;
215 }
216 // get value
217 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_VAL_INDEX, result.value);
218 if (errCode != E_OK) {
219 goto END;
220 }
221 // get device
222 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_DEVICE_INDEX, devVect);
223 if (errCode != E_OK) {
224 goto END;
225 }
226 result.device = std::string(devVect.begin(), devVect.end());
227 // get original device
228 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_ORI_DEV_INDEX, origDevVect);
229 if (errCode != E_OK) {
230 goto END;
231 }
232 result.origDevice = std::string(origDevVect.begin(), origDevVect.end());
233 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
234 errCode = -E_NOT_FOUND;
235 goto END;
236 }
237
238 END:
239 SQLiteUtils::ResetStatement(statement, true, errCode);
240 return CheckCorruptedStatus(errCode);
241 }
242
SaveKvData(SingleVerDataType type,const Key & key,const Value & value,Timestamp timestamp)243 int SQLiteSingleVerStorageExecutor::SaveKvData(SingleVerDataType type, const Key &key, const Value &value,
244 Timestamp timestamp)
245 {
246 sqlite3_stmt *statement = nullptr;
247 std::string sql;
248 if (type == SingleVerDataType::LOCAL_TYPE) {
249 sql = (executorState_ == ExecutorState::CACHE_ATTACH_MAIN ? INSERT_LOCAL_SQL_FROM_CACHEHANDLE :
250 INSERT_LOCAL_SQL);
251 } else {
252 sql = (attachMetaMode_ ? INSERT_ATTACH_META_SQL : INSERT_META_SQL);
253 }
254 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
255 if (errCode != E_OK) {
256 goto ERROR;
257 }
258
259 errCode = BindPutKvData(statement, key, value, timestamp, type);
260 if (errCode != E_OK) {
261 goto ERROR;
262 }
263
264 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
265 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
266 errCode = E_OK;
267 }
268
269 ERROR:
270 SQLiteUtils::ResetStatement(statement, true, errCode);
271 return CheckCorruptedStatus(errCode);
272 }
273
PutKvData(SingleVerDataType type,const Key & key,const Value & value,Timestamp timestamp,SingleVerNaturalStoreCommitNotifyData * committedData)274 int SQLiteSingleVerStorageExecutor::PutKvData(SingleVerDataType type, const Key &key, const Value &value,
275 Timestamp timestamp, SingleVerNaturalStoreCommitNotifyData *committedData)
276 {
277 if (type != SingleVerDataType::LOCAL_TYPE && type != SingleVerDataType::META_TYPE) {
278 return -E_INVALID_ARGS;
279 }
280 // committedData is only for local data, not for meta data.
281 bool isLocal = (SingleVerDataType::LOCAL_TYPE == type);
282 Timestamp localTimestamp = 0;
283 Value readValue;
284 bool isExisted = CheckIfKeyExisted(key, isLocal, readValue, localTimestamp);
285 if (isLocal && committedData != nullptr) {
286 ExistStatus existedStatus = isExisted ? ExistStatus::EXIST : ExistStatus::NONE;
287 Key hashKey;
288 int innerErrCode = DBCommon::CalcValueHash(key, hashKey);
289 if (innerErrCode != E_OK) {
290 return innerErrCode;
291 }
292 committedData->InitKeyPropRecord(hashKey, existedStatus);
293 }
294 int errCode = SaveKvData(type, key, value, timestamp);
295 if (errCode != E_OK) {
296 return errCode;
297 }
298
299 if (isLocal && committedData != nullptr) {
300 Entry entry = {key, value};
301 committedData->InsertCommittedData(std::move(entry), isExisted ? DataType::UPDATE : DataType::INSERT, true);
302 }
303 return E_OK;
304 }
305
GetEntries(SingleVerDataType type,const Key & keyPrefix,std::vector<Entry> & entries) const306 int SQLiteSingleVerStorageExecutor::GetEntries(SingleVerDataType type, const Key &keyPrefix,
307 std::vector<Entry> &entries) const
308 {
309 if ((type != SingleVerDataType::LOCAL_TYPE) && (type != SingleVerDataType::SYNC_TYPE)) {
310 return -E_INVALID_ARGS;
311 }
312
313 std::string sql = (type == SingleVerDataType::SYNC_TYPE) ? SELECT_SYNC_PREFIX_SQL : SELECT_LOCAL_PREFIX_SQL;
314 sqlite3_stmt *statement = nullptr;
315 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
316 if (errCode != E_OK) {
317 goto END;
318 }
319
320 // bind the prefix key for the first and second args.
321 errCode = SQLiteUtils::BindPrefixKey(statement, 1, keyPrefix); // first argument is key
322 if (errCode != E_OK) {
323 goto END;
324 }
325
326 errCode = StepForResultEntries(statement, entries);
327
328 END:
329 SQLiteUtils::ResetStatement(statement, true, errCode);
330 return CheckCorruptedStatus(errCode);
331 }
332
GetEntries(QueryObject & queryObj,std::vector<Entry> & entries) const333 int SQLiteSingleVerStorageExecutor::GetEntries(QueryObject &queryObj, std::vector<Entry> &entries) const
334 {
335 int errCode = E_OK;
336 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
337 if (errCode != E_OK) {
338 return errCode;
339 }
340
341 sqlite3_stmt *statement = nullptr;
342 errCode = helper.GetQuerySqlStatement(dbHandle_, false, statement);
343 if (errCode == E_OK) {
344 errCode = StepForResultEntries(statement, entries);
345 }
346
347 SQLiteUtils::ResetStatement(statement, true, errCode);
348 return CheckCorruptedStatus(errCode);
349 }
350
GetCount(QueryObject & queryObj,int & count) const351 int SQLiteSingleVerStorageExecutor::GetCount(QueryObject &queryObj, int &count) const
352 {
353 if (dbHandle_ == nullptr) {
354 return -E_INVALID_DB;
355 }
356
357 int errCode = E_OK;
358 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
359 if (errCode != E_OK) {
360 return errCode;
361 }
362
363 if (!queryObj.IsCountValid()) {
364 LOGE("GetCount no need limit or orderby");
365 return -E_INVALID_QUERY_FORMAT;
366 }
367
368 std::string countSql;
369 errCode = helper.GetCountQuerySql(countSql);
370 if (errCode != E_OK) {
371 return errCode;
372 }
373
374 sqlite3_stmt *countStatement = nullptr;
375 // get statement for count
376 errCode = helper.GetQuerySqlStatement(dbHandle_, countSql, countStatement);
377 if (errCode != E_OK) {
378 LOGE("Get count bind statement error:%d", errCode);
379 goto END;
380 }
381 // get count value
382 errCode = SQLiteUtils::StepWithRetry(countStatement, isMemDb_);
383 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
384 uint64_t readCount = static_cast<uint64_t>(sqlite3_column_int64(countStatement, 0));
385 if (readCount > INT32_MAX) {
386 LOGW("total count is beyond the max count");
387 count = 0;
388 errCode = -E_UNEXPECTED_DATA;
389 } else {
390 count = static_cast<int>(readCount);
391 errCode = E_OK;
392 }
393 LOGD("Entry count in this result set is %d", count);
394 } else {
395 errCode = -E_UNEXPECTED_DATA;
396 }
397
398 END:
399 SQLiteUtils::ResetStatement(countStatement, true, errCode);
400 return CheckCorruptedStatus(errCode);
401 }
402
InitCurrentMaxStamp(Timestamp & maxStamp)403 void SQLiteSingleVerStorageExecutor::InitCurrentMaxStamp(Timestamp &maxStamp)
404 {
405 if (dbHandle_ == nullptr) {
406 return;
407 }
408 std::string sql = ((executorState_ == ExecutorState::CACHE_ATTACH_MAIN) ?
409 SELECT_MAX_TIMESTAMP_SQL_FROM_CACHEHANDLE : SELECT_MAX_TIMESTAMP_SQL);
410 sqlite3_stmt *statement = nullptr;
411 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
412 if (errCode != E_OK) {
413 return;
414 }
415
416 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
417 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
418 maxStamp = static_cast<uint64_t>(sqlite3_column_int64(statement, 0)); // get the first column
419 }
420 SQLiteUtils::ResetStatement(statement, true, errCode);
421 }
422
PrepareForSyncDataByTime(Timestamp begin,Timestamp end,sqlite3_stmt * & statement,bool getDeletedData) const423 int SQLiteSingleVerStorageExecutor::PrepareForSyncDataByTime(Timestamp begin, Timestamp end,
424 sqlite3_stmt *&statement, bool getDeletedData) const
425 {
426 if (dbHandle_ == nullptr) {
427 return -E_INVALID_DB;
428 }
429
430 const std::string sql = (getDeletedData ? SELECT_SYNC_DELETED_ENTRIES_SQL : SELECT_SYNC_ENTRIES_SQL);
431 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
432 if (errCode != E_OK) {
433 LOGE("Prepare the sync entries statement error:%d", errCode);
434 return errCode;
435 }
436
437 errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_BEGIN_STAMP_INDEX, begin);
438 if (errCode != E_OK) {
439 goto ERROR;
440 }
441
442 errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_END_STAMP_INDEX, end);
443
444 ERROR:
445 if (errCode != E_OK) {
446 LOGE("Bind the timestamp for getting sync data error:%d", errCode);
447 SQLiteUtils::ResetStatement(statement, true, errCode);
448 }
449
450 return CheckCorruptedStatus(errCode);
451 }
452
ReleaseContinueStatement()453 void SQLiteSingleVerStorageExecutor::ReleaseContinueStatement()
454 {
455 if (getSyncStatement_ != nullptr) {
456 int errCode = E_OK;
457 SQLiteUtils::ResetStatement(getSyncStatement_, true, errCode);
458 if (errCode == -E_INVALID_PASSWD_OR_CORRUPTED_DB) {
459 SetCorruptedStatus();
460 }
461 }
462 }
463
464 namespace {
GetDataItemForSync(sqlite3_stmt * statement,DataItem & dataItem)465 int GetDataItemForSync(sqlite3_stmt *statement, DataItem &dataItem)
466 {
467 dataItem.timestamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
468 dataItem.writeTimestamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_W_TIME_INDEX));
469 dataItem.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
470 dataItem.flag &= (~DataItem::LOCAL_FLAG);
471 std::vector<uint8_t> devVect;
472 int errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_ORI_DEV_INDEX, devVect);
473 if (errCode != E_OK) {
474 return errCode;
475 }
476 dataItem.origDev = std::string(devVect.begin(), devVect.end());
477 int keyIndex = SYNC_RES_KEY_INDEX;
478 // If the data has been deleted, just use the hash key for sync.
479 if ((dataItem.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG) {
480 keyIndex = SYNC_RES_HASH_KEY_INDEX;
481 }
482 errCode = SQLiteUtils::GetColumnBlobValue(statement, keyIndex, dataItem.key);
483 if (errCode != E_OK) {
484 return errCode;
485 }
486 return SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_VAL_INDEX, dataItem.value);
487 }
488 }
489
GetSyncDataItems(std::vector<DataItem> & dataItems,sqlite3_stmt * statement,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo) const490 int SQLiteSingleVerStorageExecutor::GetSyncDataItems(std::vector<DataItem> &dataItems, sqlite3_stmt *statement,
491 size_t appendLength, const DataSizeSpecInfo &dataSizeInfo) const
492 {
493 int errCode;
494 size_t dataTotalSize = 0;
495
496 do {
497 DataItem dataItem;
498 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
499 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
500 errCode = GetDataItemForSync(statement, dataItem);
501 if (errCode != E_OK) {
502 LOGE("GetDataItemForSync failed:%d", errCode);
503 return errCode;
504 }
505 } else {
506 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
507 LOGD("Get sync data finished, size of packet:%zu, number of item:%zu", dataTotalSize, dataItems.size());
508 errCode = -E_FINISHED;
509 } else {
510 LOGE("Get sync data error:%d", errCode);
511 }
512 break;
513 }
514
515 // If dataTotalSize value is bigger than blockSize value , reserve the surplus data item.
516 dataTotalSize += GetDataItemSerialSize(dataItem, appendLength);
517 if ((dataTotalSize > dataSizeInfo.blockSize && !dataItems.empty()) ||
518 dataItems.size() >= dataSizeInfo.packetSize) {
519 errCode = -E_UNFINISHED;
520 break;
521 } else {
522 dataItems.push_back(std::move(dataItem));
523 }
524 } while (true);
525 return errCode;
526 }
527
GetSyncDataByTimestamp(std::vector<DataItem> & dataItems,size_t appendLength,Timestamp begin,Timestamp end,const DataSizeSpecInfo & dataSizeInfo) const528 int SQLiteSingleVerStorageExecutor::GetSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength,
529 Timestamp begin, Timestamp end, const DataSizeSpecInfo &dataSizeInfo) const
530 {
531 sqlite3_stmt *statement = nullptr;
532 int errCode = PrepareForSyncDataByTime(begin, end, statement);
533 if (errCode != E_OK) {
534 return errCode;
535 }
536
537 errCode = GetSyncDataItems(dataItems, statement, appendLength, dataSizeInfo);
538 SQLiteUtils::ResetStatement(statement, true, errCode);
539 return CheckCorruptedStatus(errCode);
540 }
541
GetDeletedSyncDataByTimestamp(std::vector<DataItem> & dataItems,size_t appendLength,Timestamp begin,Timestamp end,const DataSizeSpecInfo & dataSizeInfo) const542 int SQLiteSingleVerStorageExecutor::GetDeletedSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength,
543 Timestamp begin, Timestamp end, const DataSizeSpecInfo &dataSizeInfo) const
544 {
545 sqlite3_stmt *statement = nullptr;
546 int errCode = PrepareForSyncDataByTime(begin, end, statement, true);
547 if (errCode != E_OK) {
548 return errCode;
549 }
550
551 errCode = GetSyncDataItems(dataItems, statement, appendLength, dataSizeInfo);
552 SQLiteUtils::ResetStatement(statement, true, errCode);
553 return CheckCorruptedStatus(errCode);
554 }
555
556 namespace {
AppendDataItem(std::vector<DataItem> & dataItems,const DataItem & item,size_t & dataTotalSize,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo)557 int AppendDataItem(std::vector<DataItem> &dataItems, const DataItem &item, size_t &dataTotalSize, size_t appendLength,
558 const DataSizeSpecInfo &dataSizeInfo)
559 {
560 // If dataTotalSize value is bigger than blockSize value , reserve the surplus data item.
561 size_t appendSize = dataTotalSize + SQLiteSingleVerStorageExecutor::GetDataItemSerialSize(item, appendLength);
562 if ((appendSize > dataSizeInfo.blockSize && !dataItems.empty()) || dataItems.size() >= dataSizeInfo.packetSize) {
563 return -E_UNFINISHED;
564 }
565 dataItems.push_back(item);
566 dataTotalSize = appendSize;
567 return E_OK;
568 }
569
GetFullDataStatement(sqlite3 * db,const std::pair<Timestamp,Timestamp> & timeRange,sqlite3_stmt * & stmt)570 int GetFullDataStatement(sqlite3 *db, const std::pair<Timestamp, Timestamp> &timeRange, sqlite3_stmt *&stmt)
571 {
572 int errCode = SQLiteUtils::GetStatement(db, SELECT_SYNC_MODIFY_SQL, stmt);
573 if (errCode != E_OK) {
574 LOGE("Get statement failed. %d", errCode);
575 return errCode;
576 }
577 errCode = SQLiteUtils::BindInt64ToStatement(stmt, 1, timeRange.first); // 1 : Bind time rang index start
578 if (errCode != E_OK) {
579 LOGE("Bind time range to statement failed. %d", errCode);
580 goto ERR;
581 }
582 errCode = SQLiteUtils::BindInt64ToStatement(stmt, 2, timeRange.second); // 2 : Bind time rang index end
583 if (errCode != E_OK) {
584 LOGE("Bind time range to statement failed. %d", errCode);
585 goto ERR;
586 }
587 return E_OK; // do not release statement when success
588 ERR:
589 SQLiteUtils::ResetStatement(stmt, true, errCode);
590 return errCode;
591 }
592
GetQueryDataStatement(sqlite3 * db,QueryObject query,const std::pair<Timestamp,Timestamp> & timeRange,sqlite3_stmt * & stmt)593 int GetQueryDataStatement(sqlite3 *db, QueryObject query, const std::pair<Timestamp, Timestamp> &timeRange,
594 sqlite3_stmt *&stmt)
595 {
596 int errCode = E_OK;
597 SqliteQueryHelper helper = query.GetQueryHelper(errCode);
598 if (errCode != E_OK) {
599 return errCode;
600 }
601 return helper.GetQuerySyncStatement(db, timeRange.first, timeRange.second, stmt);
602 }
603
GetNextDataItem(sqlite3_stmt * stmt,bool isMemDB,DataItem & item)604 int GetNextDataItem(sqlite3_stmt *stmt, bool isMemDB, DataItem &item)
605 {
606 int errCode = SQLiteUtils::StepWithRetry(stmt, isMemDB);
607 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
608 errCode = GetDataItemForSync(stmt, item);
609 }
610 return errCode;
611 }
612 }
613
GetSyncDataWithQuery(const QueryObject & query,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo,const std::pair<Timestamp,Timestamp> & timeRange,std::vector<DataItem> & dataItems) const614 int SQLiteSingleVerStorageExecutor::GetSyncDataWithQuery(const QueryObject &query, size_t appendLength,
615 const DataSizeSpecInfo &dataSizeInfo, const std::pair<Timestamp, Timestamp> &timeRange,
616 std::vector<DataItem> &dataItems) const
617 {
618 sqlite3_stmt *fullStmt = nullptr; // statement for get all modified data in the time range
619 sqlite3_stmt *queryStmt = nullptr; // statement for get modified data which is matched query in the time range
620 int errCode = GetQueryDataStatement(dbHandle_, query, timeRange, queryStmt);
621 if (errCode != E_OK) {
622 LOGE("Get query matched data statement failed. %d", errCode);
623 goto END;
624 }
625 if (query.IsQueryOnlyByKey()) {
626 // Query sync by prefixKey only should not deal with REMOTE_DEVICE_DATA_MISS_QUERY. Get the data directly.
627 errCode = GetSyncDataItems(dataItems, queryStmt, appendLength, dataSizeInfo);
628 goto END;
629 }
630 errCode = GetFullDataStatement(dbHandle_, timeRange, fullStmt);
631 if (errCode != E_OK) {
632 LOGE("Get full changed data statement failed. %d", errCode);
633 goto END;
634 }
635 errCode = GetSyncDataWithQuery(fullStmt, queryStmt, appendLength, dataSizeInfo, dataItems);
636 if (errCode != E_OK && errCode != -E_UNFINISHED && errCode != -E_FINISHED) {
637 LOGE("Get sync data with query failed. %d", errCode);
638 }
639 END:
640 SQLiteUtils::ResetStatement(fullStmt, true, errCode);
641 SQLiteUtils::ResetStatement(queryStmt, true, errCode);
642 return CheckCorruptedStatus(errCode);
643 }
644
GetSyncDataWithQuery(sqlite3_stmt * fullStmt,sqlite3_stmt * queryStmt,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo,std::vector<DataItem> & dataItems) const645 int SQLiteSingleVerStorageExecutor::GetSyncDataWithQuery(sqlite3_stmt *fullStmt, sqlite3_stmt *queryStmt,
646 size_t appendLength, const DataSizeSpecInfo &dataSizeInfo, std::vector<DataItem> &dataItems) const
647 {
648 int errCode = E_OK;
649 size_t dataTotalSize = 0;
650 DataItem fullItem;
651 DataItem matchItem;
652 bool isFullItemFinished = false;
653 bool isMatchItemFinished = false;
654 while (!isFullItemFinished || !isMatchItemFinished) {
655 errCode = GetNextDataItem(queryStmt, isMemDb_, matchItem);
656 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // query finished
657 isMatchItemFinished = true;
658 } else if (errCode != E_OK) { // step failed or get data failed
659 LOGE("Get next query matched data failed. %d", errCode);
660 return errCode;
661 }
662 while (!isFullItemFinished) {
663 errCode = GetNextDataItem(fullStmt, isMemDb_, fullItem);
664 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // queryStmt is a subset of fullStmt
665 isFullItemFinished = true;
666 break;
667 } else if (errCode != E_OK) { // step failed or get data failed
668 LOGE("Get next changed data failed. %d", errCode);
669 return errCode;
670 }
671 bool matchData = true;
672 if (isMatchItemFinished || matchItem.key != fullItem.key) {
673 matchData = false; // got miss query data
674 DBCommon::CalcValueHash(fullItem.key, fullItem.key); // set and send key with hash_key
675 Value().swap(fullItem.value); // not send value when data miss query
676 fullItem.flag |= DataItem::REMOTE_DEVICE_DATA_MISS_QUERY; // mark with miss query flag
677 }
678 errCode = AppendDataItem(dataItems, fullItem, dataTotalSize, appendLength, dataSizeInfo);
679 if (errCode == -E_UNFINISHED) {
680 goto END;
681 }
682 if (matchData) {
683 break; // step to next match data
684 }
685 }
686 }
687 END:
688 LOGD("Get sync data finished, size of packet:%zu, number of item:%zu", dataTotalSize, dataItems.size());
689 return (isFullItemFinished && isMatchItemFinished) ? -E_FINISHED : errCode;
690 }
691
OpenResultSet(const Key & keyPrefix,int & count)692 int SQLiteSingleVerStorageExecutor::OpenResultSet(const Key &keyPrefix, int &count)
693 {
694 sqlite3_stmt *countStatement = nullptr;
695 if (InitResultSet(keyPrefix, countStatement) != E_OK) {
696 LOGE("Initialize result set stat failed.");
697 return -E_INVALID_DB;
698 }
699
700 int errCode = StartTransaction(TransactType::DEFERRED);
701 if (errCode != E_OK) {
702 goto END;
703 }
704
705 // get count value
706 errCode = SQLiteUtils::StepWithRetry(countStatement, isMemDb_);
707 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
708 uint64_t readCount = static_cast<uint64_t>(sqlite3_column_int64(countStatement, 0));
709 if (readCount > INT32_MAX) {
710 LOGW("total count is beyond the max count");
711 count = 0;
712 errCode = -E_UNEXPECTED_DATA;
713 } else {
714 count = static_cast<int>(readCount);
715 errCode = E_OK;
716 }
717 LOGD("Entry count in this result set is %d", count);
718 } else {
719 errCode = -E_UNEXPECTED_DATA;
720 }
721
722 END:
723 SQLiteUtils::ResetStatement(countStatement, true, errCode);
724 if (errCode != E_OK) {
725 CloseResultSet();
726 }
727 return CheckCorruptedStatus(errCode);
728 }
729
OpenResultSet(QueryObject & queryObj,int & count)730 int SQLiteSingleVerStorageExecutor::OpenResultSet(QueryObject &queryObj, int &count)
731 {
732 sqlite3_stmt *countStatement = nullptr;
733 int errCode = InitResultSet(queryObj, countStatement);
734 if (errCode != E_OK) {
735 LOGE("Initialize result set stat failed.");
736 return errCode;
737 }
738
739 errCode = StartTransaction(TransactType::DEFERRED);
740 if (errCode != E_OK) {
741 goto END;
742 }
743
744 // get count value
745 errCode = SQLiteUtils::StepWithRetry(countStatement, isMemDb_);
746 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
747 uint64_t readCount = static_cast<uint64_t>(sqlite3_column_int64(countStatement, 0));
748 if (queryObj.HasLimit()) {
749 int limit = 0;
750 int offset = 0;
751 queryObj.GetLimitVal(limit, offset);
752 offset = (offset < 0) ? 0 : offset;
753 limit = (limit < 0) ? 0 : limit;
754 if (readCount <= static_cast<uint64_t>(offset)) {
755 readCount = 0;
756 } else {
757 readCount = std::min(readCount - offset, static_cast<uint64_t>(limit));
758 }
759 }
760
761 if (readCount > INT32_MAX) {
762 LOGW("total count is beyond the max count");
763 count = 0;
764 errCode = -E_UNEXPECTED_DATA;
765 } else {
766 count = static_cast<int>(readCount);
767 errCode = E_OK;
768 }
769 LOGD("Entry count in this result set is %d", count);
770 } else {
771 errCode = -E_UNEXPECTED_DATA;
772 }
773
774 END:
775 SQLiteUtils::ResetStatement(countStatement, true, errCode);
776 if (errCode != E_OK) {
777 CloseResultSet();
778 }
779 return CheckCorruptedStatus(errCode);
780 }
781
OpenResultSetForCacheRowIdMode(const Key & keyPrefix,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,int & count)782 int SQLiteSingleVerStorageExecutor::OpenResultSetForCacheRowIdMode(const Key &keyPrefix,
783 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, int &count)
784 {
785 if (dbHandle_ == nullptr) {
786 return -E_INVALID_DB;
787 }
788 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_ROWID_PREFIX_SQL, getResultRowIdStatement_);
789 if (errCode != E_OK) {
790 LOGE("[SqlSinExe][OpenResSetRowId][PrefixKey] Get rowId stmt fail, errCode=%d", errCode);
791 return CheckCorruptedStatus(errCode);
792 }
793 errCode = SQLiteUtils::BindPrefixKey(getResultRowIdStatement_, 1, keyPrefix); // first argument index is 1
794 if (errCode != E_OK) {
795 LOGE("[SqlSinExe][OpenResSetRowId][PrefixKey] Bind rowid stmt fail, errCode=%d", errCode);
796 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
797 return CheckCorruptedStatus(errCode);
798 }
799 errCode = OpenResultSetForCacheRowIdModeCommon(rowIdCache, cacheLimit, count);
800 if (errCode != E_OK) {
801 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
802 }
803 return errCode;
804 }
805
OpenResultSetForCacheRowIdMode(QueryObject & queryObj,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,int & count)806 int SQLiteSingleVerStorageExecutor::OpenResultSetForCacheRowIdMode(QueryObject &queryObj,
807 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, int &count)
808 {
809 if (dbHandle_ == nullptr) {
810 return -E_INVALID_DB;
811 }
812
813 int errCode = E_OK;
814 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
815 if (errCode != E_OK) {
816 return errCode;
817 }
818
819 if (!queryObj.IsValid()) {
820 LOGE("[SqlSinExe][OpenResSetRowId][Query] query object not Valid");
821 return -E_INVALID_QUERY_FORMAT;
822 }
823
824 errCode = helper.GetQuerySqlStatement(dbHandle_, true, getResultRowIdStatement_);
825 if (errCode != E_OK) {
826 LOGE("[SqlSinExe][OpenResSetRowId][Query] Get Stmt fail, errCode=%d", errCode);
827 // The GetQuerySqlStatement does not self rollback(BAD...), so we have to reset the stmt here.
828 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
829 return errCode;
830 }
831 errCode = OpenResultSetForCacheRowIdModeCommon(rowIdCache, cacheLimit, count);
832 if (errCode != E_OK) {
833 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
834 }
835 return errCode;
836 }
837
ReloadResultSet(const Key & keyPrefix)838 int SQLiteSingleVerStorageExecutor::ReloadResultSet(const Key &keyPrefix)
839 {
840 int errCode = ResetOrRegetStmt(dbHandle_, getResultRowIdStatement_, SELECT_SYNC_ROWID_PREFIX_SQL);
841 if (errCode != E_OK) {
842 return CheckCorruptedStatus(errCode);
843 }
844
845 // No need to reset getResultEntryStatement_. Because the binding of it will be cleared in each get operation
846 errCode = SQLiteUtils::BindPrefixKey(getResultRowIdStatement_, 1, keyPrefix); // first argument is key
847 if (errCode != E_OK) {
848 LOGE("Rebind result set rowid statement of keyPrefix error:%d", errCode);
849 return CheckCorruptedStatus(errCode);
850 }
851 return E_OK;
852 }
853
ReloadResultSet(QueryObject & queryObj)854 int SQLiteSingleVerStorageExecutor::ReloadResultSet(QueryObject &queryObj)
855 {
856 int errCode = E_OK;
857 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
858 if (errCode != E_OK) {
859 return errCode;
860 }
861
862 if (!queryObj.IsValid()) {
863 return -E_INVALID_QUERY_FORMAT;
864 }
865
866 std::string sql;
867 errCode = helper.GetQuerySql(sql, true); // only rowid sql
868 if (errCode != E_OK) {
869 return errCode;
870 }
871
872 errCode = ResetOrRegetStmt(dbHandle_, getResultRowIdStatement_, sql);
873 if (errCode != E_OK) {
874 return CheckCorruptedStatus(errCode);
875 }
876
877 // No need to reset getResultEntryStatement_. Because the binding of it will be cleared in each get operation
878 // GetQuerySqlStatement will not alter getResultRowIdStatement_ if it is not null
879 errCode = helper.GetQuerySqlStatement(dbHandle_, true, getResultRowIdStatement_);
880 if (errCode != E_OK) {
881 LOGE("Rebind result set rowid statement of query error:%d", errCode);
882 return CheckCorruptedStatus(errCode);
883 }
884 return E_OK;
885 }
886
ReloadResultSetForCacheRowIdMode(const Key & keyPrefix,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,uint32_t cacheStartPos)887 int SQLiteSingleVerStorageExecutor::ReloadResultSetForCacheRowIdMode(const Key &keyPrefix,
888 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, uint32_t cacheStartPos)
889 {
890 int errCode = ReloadResultSet(keyPrefix); // Reuse this function(A convenience)
891 if (errCode != E_OK) {
892 return errCode;
893 }
894 int count = 0; // Ignored
895 errCode = ResultSetLoadRowIdCache(rowIdCache, cacheLimit, cacheStartPos, count);
896 if (errCode != E_OK) {
897 LOGE("[SqlSinExe][ReloadResSet][KeyPrefix] Load fail, errCode=%d", errCode);
898 }
899 // We can just return, no need to reset the statement
900 return errCode;
901 }
902
ReloadResultSetForCacheRowIdMode(QueryObject & queryObj,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,uint32_t cacheStartPos)903 int SQLiteSingleVerStorageExecutor::ReloadResultSetForCacheRowIdMode(QueryObject &queryObj,
904 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, uint32_t cacheStartPos)
905 {
906 int errCode = ReloadResultSet(queryObj); // Reuse this function(A convenience)
907 if (errCode != E_OK) {
908 return errCode;
909 }
910 int count = 0; // Ignored
911 errCode = ResultSetLoadRowIdCache(rowIdCache, cacheLimit, cacheStartPos, count);
912 if (errCode != E_OK) {
913 LOGE("[SqlSinExe][ReloadResSet][Query] Load fail, errCode=%d", errCode);
914 }
915 // We can just return, no need to reset the statement
916 return errCode;
917 }
918
GetNextEntryFromResultSet(Key & key,Value & value,bool isCopy)919 int SQLiteSingleVerStorageExecutor::GetNextEntryFromResultSet(Key &key, Value &value, bool isCopy)
920 {
921 if (getResultRowIdStatement_ == nullptr || getResultEntryStatement_ == nullptr) {
922 return -E_RESULT_SET_STATUS_INVALID;
923 }
924
925 int errCode = SQLiteUtils::StepWithRetry(getResultRowIdStatement_, isMemDb_);
926 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
927 if (!isCopy) {
928 return E_OK;
929 }
930 int64_t rowId = sqlite3_column_int64(getResultRowIdStatement_, 0);
931 errCode = E_OK;
932 SQLiteUtils::ResetStatement(getResultEntryStatement_, false, errCode);
933 if (errCode != E_OK) {
934 LOGE("[SqlSinExe][GetNext] Reset result set entry statement fail, errCode=%d.", errCode);
935 return CheckCorruptedStatus(errCode);
936 }
937
938 SQLiteUtils::BindInt64ToStatement(getResultEntryStatement_, 1, rowId);
939 errCode = SQLiteUtils::StepWithRetry(getResultEntryStatement_, isMemDb_);
940 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
941 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 0, key);
942 if (errCode != E_OK) {
943 LOGE("[SqlSinExe][GetNext] Get key failed:%d", errCode);
944 return CheckCorruptedStatus(errCode);
945 }
946 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 1, value);
947 if (errCode != E_OK) {
948 LOGE("[SqlSinExe][GetNext] Get value failed:%d", errCode);
949 return CheckCorruptedStatus(errCode);
950 }
951 return E_OK;
952 } else {
953 return -E_UNEXPECTED_DATA;
954 }
955 }
956 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
957 return -E_FINISHED;
958 }
959
960 LOGE("SQLite step failed:%d", errCode);
961 return CheckCorruptedStatus(errCode);
962 }
963
GetEntryByRowId(int64_t rowId,Entry & entry)964 int SQLiteSingleVerStorageExecutor::GetEntryByRowId(int64_t rowId, Entry &entry)
965 {
966 if (getResultEntryStatement_ == nullptr) {
967 return -E_RESULT_SET_STATUS_INVALID;
968 }
969 int errCode = E_OK;
970 SQLiteUtils::ResetStatement(getResultEntryStatement_, false, errCode);
971 if (errCode != E_OK) {
972 LOGE("[SqlSinExe][GetEntryByRowid] Reset result set entry statement fail, errCode=%d.", errCode);
973 return CheckCorruptedStatus(errCode);
974 }
975 SQLiteUtils::BindInt64ToStatement(getResultEntryStatement_, 1, rowId);
976 errCode = SQLiteUtils::StepWithRetry(getResultEntryStatement_, isMemDb_);
977 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
978 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 0, entry.key);
979 if (errCode != E_OK) {
980 LOGE("[SqlSinExe][GetEntryByRowid] Get key failed, errCode=%d.", errCode);
981 return CheckCorruptedStatus(errCode);
982 }
983 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 1, entry.value);
984 if (errCode != E_OK) {
985 LOGE("[SqlSinExe][GetEntryByRowid] Get value failed, errCode=%d.", errCode);
986 return CheckCorruptedStatus(errCode);
987 }
988 return E_OK;
989 } else {
990 LOGE("[SqlSinExe][GetEntryByRowid] Step failed, errCode=%d.", errCode);
991 return -E_UNEXPECTED_DATA;
992 }
993 }
994
CloseResultSet()995 void SQLiteSingleVerStorageExecutor::CloseResultSet()
996 {
997 int errCode = E_OK;
998 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
999 if (errCode == -E_INVALID_PASSWD_OR_CORRUPTED_DB) {
1000 SetCorruptedStatus();
1001 }
1002 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
1003 if (errCode == -E_INVALID_PASSWD_OR_CORRUPTED_DB) {
1004 SetCorruptedStatus();
1005 }
1006 if (isTransactionOpen_) {
1007 SQLiteUtils::RollbackTransaction(dbHandle_);
1008 isTransactionOpen_ = false;
1009 }
1010 }
1011
StartTransaction(TransactType type)1012 int SQLiteSingleVerStorageExecutor::StartTransaction(TransactType type)
1013 {
1014 if (dbHandle_ == nullptr) {
1015 LOGE("Begin transaction failed, dbHandle is null.");
1016 return -E_INVALID_DB;
1017 }
1018 int errCode = SQLiteUtils::BeginTransaction(dbHandle_, type);
1019 if (errCode == E_OK) {
1020 isTransactionOpen_ = true;
1021 } else {
1022 LOGE("Begin transaction failed, errCode = %d", errCode);
1023 }
1024 return CheckCorruptedStatus(errCode);
1025 }
1026
Commit()1027 int SQLiteSingleVerStorageExecutor::Commit()
1028 {
1029 if (dbHandle_ == nullptr) {
1030 return -E_INVALID_DB;
1031 }
1032 int errCode = SQLiteUtils::CommitTransaction(dbHandle_);
1033 if (errCode != E_OK) {
1034 return CheckCorruptedStatus(errCode);
1035 }
1036 isTransactionOpen_ = false;
1037 return E_OK;
1038 }
1039
Rollback()1040 int SQLiteSingleVerStorageExecutor::Rollback()
1041 {
1042 if (dbHandle_ == nullptr) {
1043 return -E_INVALID_DB;
1044 }
1045 int errCode = SQLiteUtils::RollbackTransaction(dbHandle_);
1046 if (errCode != E_OK) {
1047 LOGE("sqlite single ver storage executor rollback fail! errCode = [%d]", errCode);
1048 return CheckCorruptedStatus(errCode);
1049 }
1050 isTransactionOpen_ = false;
1051 return E_OK;
1052 }
1053
CheckIfKeyExisted(const Key & key,bool isLocal,Value & value,Timestamp & timestamp) const1054 bool SQLiteSingleVerStorageExecutor::CheckIfKeyExisted(const Key &key, bool isLocal,
1055 Value &value, Timestamp ×tamp) const
1056 {
1057 // not local value, no need to get the value.
1058 if (!isLocal) {
1059 return false;
1060 }
1061
1062 int errCode = GetKvData(SingleVerDataType::LOCAL_TYPE, key, value, timestamp);
1063 if (errCode != E_OK) {
1064 return false;
1065 }
1066 return true;
1067 }
1068
GetDeviceIdentifier(PragmaEntryDeviceIdentifier * identifier)1069 int SQLiteSingleVerStorageExecutor::GetDeviceIdentifier(PragmaEntryDeviceIdentifier *identifier)
1070 {
1071 if (identifier == nullptr) {
1072 return -E_INVALID_ARGS;
1073 }
1074
1075 if (dbHandle_ == nullptr) {
1076 return -E_INVALID_DB;
1077 }
1078
1079 sqlite3_stmt *statement = nullptr;
1080 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_ENTRY_DEVICE, statement);
1081 if (errCode != E_OK) {
1082 return errCode;
1083 }
1084
1085 int keyIndex = identifier->origDevice ? BIND_ORI_DEVICE_ID : BIND_PRE_DEVICE_ID;
1086 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_KV_KEY_INDEX, identifier->key, false);
1087 if (errCode != E_OK) {
1088 goto END;
1089 }
1090
1091 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1092 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1093 std::vector<uint8_t> deviceId;
1094 errCode = SQLiteUtils::GetColumnBlobValue(statement, keyIndex, deviceId);
1095 identifier->deviceIdentifier.assign(deviceId.begin(), deviceId.end());
1096 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1097 errCode = -E_NOT_FOUND;
1098 }
1099
1100 END:
1101 SQLiteUtils::ResetStatement(statement, true, errCode);
1102 return CheckCorruptedStatus(errCode);
1103 }
1104
PutIntoCommittedData(const DataItem & itemPut,const DataItem & itemGet,const DataOperStatus & status,const Key & hashKey,SingleVerNaturalStoreCommitNotifyData * committedData)1105 void SQLiteSingleVerStorageExecutor::PutIntoCommittedData(const DataItem &itemPut, const DataItem &itemGet,
1106 const DataOperStatus &status, const Key &hashKey, SingleVerNaturalStoreCommitNotifyData *committedData)
1107 {
1108 if (committedData == nullptr) {
1109 return;
1110 }
1111
1112 Entry entry;
1113 int errCode;
1114 if (!status.isDeleted) {
1115 entry.key = itemPut.key;
1116 entry.value = itemPut.value;
1117 DataType dataType = (status.preStatus == DataStatus::EXISTED) ? DataType::UPDATE : DataType::INSERT;
1118 errCode = committedData->InsertCommittedData(std::move(entry), dataType, true);
1119 } else {
1120 entry.key = itemGet.key;
1121 entry.value = itemGet.value;
1122 errCode = committedData->InsertCommittedData(std::move(entry), DataType::DELETE, true);
1123 }
1124
1125 if (errCode != E_OK) {
1126 LOGE("[SingleVerExe][PutCommitData]Insert failed:%d", errCode);
1127 }
1128 }
1129
PrepareForSavingData(const std::string & readSql,const std::string & insertSql,const std::string & updateSql,SaveRecordStatements & statements) const1130 int SQLiteSingleVerStorageExecutor::PrepareForSavingData(const std::string &readSql, const std::string &insertSql,
1131 const std::string &updateSql, SaveRecordStatements &statements) const
1132 {
1133 int errCode = SQLiteUtils::GetStatement(dbHandle_, readSql, statements.queryStatement);
1134 if (errCode != E_OK) {
1135 LOGE("Get query statement failed. errCode = [%d]", errCode);
1136 goto ERR;
1137 }
1138
1139 errCode = SQLiteUtils::GetStatement(dbHandle_, insertSql, statements.insertStatement);
1140 if (errCode != E_OK) {
1141 LOGE("Get insert statement failed. errCode = [%d]", errCode);
1142 goto ERR;
1143 }
1144
1145 errCode = SQLiteUtils::GetStatement(dbHandle_, updateSql, statements.updateStatement);
1146 if (errCode != E_OK) {
1147 LOGE("Get update statement failed. errCode = [%d]", errCode);
1148 goto ERR;
1149 }
1150 return E_OK;
1151 ERR:
1152 (void)statements.ResetStatement();
1153 return errCode;
1154 }
1155
PrepareForSavingData(SingleVerDataType type)1156 int SQLiteSingleVerStorageExecutor::PrepareForSavingData(SingleVerDataType type)
1157 {
1158 int errCode = -E_NOT_SUPPORT;
1159 if (type == SingleVerDataType::LOCAL_TYPE) {
1160 // currently, Local type has not been optimized, so pass updateSql parameter with INSERT_LOCAL_SQL
1161 errCode = PrepareForSavingData(SELECT_LOCAL_HASH_SQL, INSERT_LOCAL_SQL, INSERT_LOCAL_SQL, saveLocalStatements_);
1162 } else if (type == SingleVerDataType::SYNC_TYPE) {
1163 errCode = PrepareForSavingData(SELECT_SYNC_HASH_SQL, INSERT_SYNC_SQL, UPDATE_SYNC_SQL, saveSyncStatements_);
1164 }
1165 return CheckCorruptedStatus(errCode);
1166 }
1167
ResetForSavingData(SingleVerDataType type)1168 int SQLiteSingleVerStorageExecutor::ResetForSavingData(SingleVerDataType type)
1169 {
1170 int errCode = E_OK;
1171 if (type == SingleVerDataType::LOCAL_TYPE) {
1172 SQLiteUtils::ResetStatement(saveLocalStatements_.insertStatement, false, errCode);
1173 SQLiteUtils::ResetStatement(saveLocalStatements_.updateStatement, false, errCode);
1174 SQLiteUtils::ResetStatement(saveLocalStatements_.queryStatement, false, errCode);
1175 } else if (type == SingleVerDataType::SYNC_TYPE) {
1176 SQLiteUtils::ResetStatement(saveSyncStatements_.insertStatement, false, errCode);
1177 SQLiteUtils::ResetStatement(saveSyncStatements_.updateStatement, false, errCode);
1178 SQLiteUtils::ResetStatement(saveSyncStatements_.queryStatement, false, errCode);
1179 }
1180 return CheckCorruptedStatus(errCode);
1181 }
1182
GetOriginDevName(const DataItem & dataItem,const std::string & origDevGet)1183 std::string SQLiteSingleVerStorageExecutor::GetOriginDevName(const DataItem &dataItem,
1184 const std::string &origDevGet)
1185 {
1186 if (((dataItem.flag & DataItem::LOCAL_FLAG) != 0) && dataItem.origDev.empty()) {
1187 return origDevGet;
1188 }
1189 return dataItem.origDev;
1190 }
1191
SaveSyncDataToDatabase(const DataItem & dataItem,const Key & hashKey,const std::string & origDev,const std::string & deviceName,bool isUpdate)1192 int SQLiteSingleVerStorageExecutor::SaveSyncDataToDatabase(const DataItem &dataItem, const Key &hashKey,
1193 const std::string &origDev, const std::string &deviceName, bool isUpdate)
1194 {
1195 if ((dataItem.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) {
1196 LOGD("Find query data missing, erase local data.");
1197 return EraseSyncData(hashKey);
1198 }
1199 auto statement = saveSyncStatements_.GetDataSaveStatement(isUpdate);
1200 if (statement == nullptr) {
1201 return -E_INVALID_ARGS;
1202 }
1203
1204 std::string devName = DBCommon::TransferHashString(deviceName);
1205 int errCode = BindSavedSyncData(statement, dataItem, hashKey, {origDev, devName}, isUpdate);
1206 if (errCode != E_OK) {
1207 return errCode;
1208 }
1209
1210 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1211 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1212 errCode = E_OK;
1213 }
1214 return errCode;
1215 }
1216
JudgeSyncSaveType(DataItem & dataItem,const DataItem & itemGet,const std::string & devName,bool isHashKeyExisted,bool isPermitForceWrite)1217 DataOperStatus SQLiteSingleVerStorageExecutor::JudgeSyncSaveType(DataItem &dataItem,
1218 const DataItem &itemGet, const std::string &devName, bool isHashKeyExisted, bool isPermitForceWrite)
1219 {
1220 DataOperStatus status;
1221 status.isDeleted = ((dataItem.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
1222 (dataItem.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY);
1223 if (isHashKeyExisted) {
1224 if ((itemGet.flag & DataItem::DELETE_FLAG) != 0) {
1225 status.preStatus = DataStatus::DELETED;
1226 } else {
1227 status.preStatus = DataStatus::EXISTED;
1228 }
1229 std::string deviceName = DBCommon::TransferHashString(devName);
1230 if (itemGet.writeTimestamp >= dataItem.writeTimestamp) {
1231 // for multi user mode, no permit to forcewrite
1232 if ((!deviceName.empty()) && (itemGet.dev == deviceName) && isPermitForceWrite) {
1233 LOGI("Force overwrite the data:%" PRIu64 " vs %" PRIu64,
1234 itemGet.writeTimestamp, dataItem.writeTimestamp);
1235 status.isDefeated = false;
1236 dataItem.writeTimestamp = itemGet.writeTimestamp + 1;
1237 dataItem.timestamp = itemGet.timestamp;
1238 } else {
1239 status.isDefeated = true;
1240 }
1241 }
1242 }
1243 return status;
1244 }
1245
GetSyncDataItemExt(const DataItem & dataItem,DataItem & itemGet,const DataOperStatus & dataStatus) const1246 int SQLiteSingleVerStorageExecutor::GetSyncDataItemExt(const DataItem &dataItem, DataItem &itemGet,
1247 const DataOperStatus &dataStatus) const
1248 {
1249 if (dataStatus.preStatus != DataStatus::EXISTED) {
1250 return E_OK;
1251 }
1252 auto statement = isSyncMigrating_ ? migrateSyncStatements_.queryStatement : saveSyncStatements_.queryStatement;
1253 // only deleted item need origin value.
1254 int errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, itemGet.key);
1255 if (errCode != E_OK) {
1256 return errCode;
1257 }
1258
1259 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_VAL_INDEX, itemGet.value);
1260 if (errCode != E_OK) {
1261 LOGE("Get column value data failed:%d", errCode);
1262 }
1263
1264 return errCode;
1265 }
1266
ResetSaveSyncStatements(int errCode)1267 int SQLiteSingleVerStorageExecutor::ResetSaveSyncStatements(int errCode)
1268 {
1269 SQLiteUtils::ResetStatement(saveSyncStatements_.insertStatement, false, errCode);
1270 SQLiteUtils::ResetStatement(saveSyncStatements_.updateStatement, false, errCode);
1271 SQLiteUtils::ResetStatement(saveSyncStatements_.queryStatement, false, errCode);
1272 return CheckCorruptedStatus(errCode);
1273 }
1274
1275 namespace {
IsNeedIgnoredData(const DataItem & itemPut,const DataItem & itemGet,const DeviceInfo & devInfo,bool isHashKeyExisted,int policy)1276 inline bool IsNeedIgnoredData(const DataItem &itemPut, const DataItem &itemGet,
1277 const DeviceInfo &devInfo, bool isHashKeyExisted, int policy)
1278 {
1279 // deny the data synced from other dev which the origin dev is current or the existed value is current dev data.
1280 return (((itemGet.origDev.empty() && isHashKeyExisted) || itemPut.origDev.empty()) &&
1281 (!devInfo.isLocal && policy == DENY_OTHER_DEV_AMEND_CUR_DEV_DATA));
1282 }
1283 }
1284
PrepareForNotifyConflictAndObserver(DataItem & dataItem,const DeviceInfo & deviceInfo,NotifyConflictAndObserverData & notify,bool isPermitForceWrite)1285 int SQLiteSingleVerStorageExecutor::PrepareForNotifyConflictAndObserver(DataItem &dataItem,
1286 const DeviceInfo &deviceInfo, NotifyConflictAndObserverData ¬ify, bool isPermitForceWrite)
1287 {
1288 // Check sava data existed info
1289 int errCode = GetSyncDataItemPre(dataItem, notify.getData, notify.hashKey);
1290 if (errCode != E_OK && errCode != -E_NOT_FOUND) {
1291 LOGD("[SingleVerExe][PrepareForNotifyConflictAndObserver] failed:%d", errCode);
1292 if (isSyncMigrating_) {
1293 ResetForMigrateCacheData();
1294 return errCode;
1295 }
1296 return ResetSaveSyncStatements(errCode);
1297 }
1298
1299 bool isHashKeyExisted = (errCode != -E_NOT_FOUND);
1300 if (IsNeedIgnoredData(dataItem, notify.getData, deviceInfo, isHashKeyExisted, conflictResolvePolicy_)) {
1301 LOGD("[SingleVerExe] Ignore the sync data.");
1302 if (isSyncMigrating_) {
1303 ResetForMigrateCacheData();
1304 return -E_IGNORE_DATA;
1305 }
1306 return ResetSaveSyncStatements(-E_IGNORE_DATA);
1307 }
1308
1309 notify.dataStatus = JudgeSyncSaveType(dataItem, notify.getData, deviceInfo.deviceName, isHashKeyExisted,
1310 isPermitForceWrite);
1311 InitCommitNotifyDataKeyStatus(notify.committedData, notify.hashKey, notify.dataStatus);
1312
1313 // Nonexistent data, but deleted by local.
1314 if ((notify.dataStatus.preStatus == DataStatus::DELETED || notify.dataStatus.preStatus == DataStatus::NOEXISTED) &&
1315 (dataItem.flag & DataItem::DELETE_FLAG) != 0 &&
1316 (dataItem.flag & DataItem::LOCAL_FLAG) != 0) {
1317 // For delete item in cacheDB, which not in mainDB. Cannot notify, but this is not error.
1318 errCode = -E_NOT_FOUND;
1319 LOGD("Nonexistent data, but deleted by local");
1320 if (isSyncMigrating_) {
1321 ResetForMigrateCacheData();
1322 return errCode;
1323 }
1324 return ResetSaveSyncStatements(errCode);
1325 }
1326
1327 // get key and value from ori database
1328 errCode = GetSyncDataItemExt(dataItem, notify.getData, notify.dataStatus);
1329 if (errCode != E_OK) {
1330 LOGD("GetSyncDataItemExt failed:%d", errCode);
1331 if (isSyncMigrating_) {
1332 ResetForMigrateCacheData();
1333 return errCode;
1334 }
1335 return ResetSaveSyncStatements(errCode);
1336 }
1337
1338 return E_OK;
1339 }
1340
SaveSyncDataItem(DataItem & dataItem,const DeviceInfo & deviceInfo,Timestamp & maxStamp,SingleVerNaturalStoreCommitNotifyData * committedData,bool isPermitForceWrite)1341 int SQLiteSingleVerStorageExecutor::SaveSyncDataItem(DataItem &dataItem, const DeviceInfo &deviceInfo,
1342 Timestamp &maxStamp, SingleVerNaturalStoreCommitNotifyData *committedData, bool isPermitForceWrite)
1343 {
1344 NotifyConflictAndObserverData notify = {
1345 .committedData = committedData
1346 };
1347
1348 int errCode = PrepareForNotifyConflictAndObserver(dataItem, deviceInfo, notify, isPermitForceWrite);
1349 if (errCode != E_OK) {
1350 if (errCode == -E_IGNORE_DATA) {
1351 errCode = E_OK;
1352 }
1353 return errCode;
1354 }
1355
1356 PutConflictData(dataItem, notify.getData, deviceInfo, notify.dataStatus, committedData);
1357 if (notify.dataStatus.isDefeated) {
1358 LOGD("Data status is defeated:%d", errCode);
1359 return ResetSaveSyncStatements(errCode);
1360 }
1361
1362 bool isUpdate = (notify.dataStatus.preStatus != DataStatus::NOEXISTED);
1363 std::string origDev = GetOriginDevName(dataItem, notify.getData.origDev);
1364 errCode = SaveSyncDataToDatabase(dataItem, notify.hashKey, origDev, deviceInfo.deviceName, isUpdate);
1365 if (errCode == E_OK) {
1366 PutIntoCommittedData(dataItem, notify.getData, notify.dataStatus, notify.hashKey, committedData);
1367 maxStamp = std::max(dataItem.timestamp, maxStamp);
1368 } else {
1369 LOGE("Save sync data to db failed:%d", errCode);
1370 }
1371 return ResetSaveSyncStatements(errCode);
1372 }
1373
GetAllMetaKeys(std::vector<Key> & keys) const1374 int SQLiteSingleVerStorageExecutor::GetAllMetaKeys(std::vector<Key> &keys) const
1375 {
1376 sqlite3_stmt *statement = nullptr;
1377 const std::string &sqlStr = (attachMetaMode_ ? SELECT_ATTACH_ALL_META_KEYS : SELECT_ALL_META_KEYS);
1378 int errCode = SQLiteUtils::GetStatement(dbHandle_, sqlStr, statement);
1379 if (errCode != E_OK) {
1380 LOGE("[SingleVerExe][GetAllKey] Get statement failed:%d", errCode);
1381 return errCode;
1382 }
1383
1384 errCode = GetAllKeys(statement, keys);
1385 SQLiteUtils::ResetStatement(statement, true, errCode);
1386 return errCode;
1387 }
1388
GetAllSyncedEntries(const std::string & deviceName,std::vector<Entry> & entries) const1389 int SQLiteSingleVerStorageExecutor::GetAllSyncedEntries(const std::string &deviceName,
1390 std::vector<Entry> &entries) const
1391 {
1392 sqlite3_stmt *statement = nullptr;
1393 std::string sql = (executorState_ == ExecutorState::CACHE_ATTACH_MAIN ?
1394 SELECT_ALL_SYNC_ENTRIES_BY_DEV_FROM_CACHEHANDLE : SELECT_ALL_SYNC_ENTRIES_BY_DEV);
1395 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
1396 if (errCode != E_OK) {
1397 LOGE("Get all entries statement failed:%d", errCode);
1398 return errCode;
1399 }
1400
1401 // When removing device data in cache mode, key is "remove", value is deviceID's hash string.
1402 // Therefore, no need to transfer hash string when migrating.
1403 std::string devName = isSyncMigrating_ ? deviceName : DBCommon::TransferHashString(deviceName);
1404 std::vector<uint8_t> devVect(devName.begin(), devName.end());
1405 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, devVect, true); // bind the 1st to device.
1406 if (errCode != E_OK) {
1407 LOGE("Failed to bind the synced device for all entries:%d", errCode);
1408 } else {
1409 errCode = GetAllEntries(statement, entries);
1410 }
1411
1412 SQLiteUtils::ResetStatement(statement, true, errCode);
1413 return errCode;
1414 }
1415
GetAllEntries(sqlite3_stmt * statement,std::vector<Entry> & entries) const1416 int SQLiteSingleVerStorageExecutor::GetAllEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const
1417 {
1418 if (statement == nullptr) {
1419 return -E_INVALID_DB;
1420 }
1421 int errCode;
1422 do {
1423 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1424 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1425 Entry entry;
1426 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, entry.key); // No.0 is the key
1427 if (errCode != E_OK) {
1428 break;
1429 }
1430 errCode = SQLiteUtils::GetColumnBlobValue(statement, 1, entry.value); // No.1 is the value
1431 if (errCode != E_OK) {
1432 break;
1433 }
1434
1435 entries.push_back(std::move(entry));
1436 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1437 errCode = E_OK;
1438 break;
1439 } else {
1440 LOGE("SQLite step for all entries failed:%d", errCode);
1441 break;
1442 }
1443 } while (true);
1444
1445 return errCode;
1446 }
1447
GetAllKeys(sqlite3_stmt * statement,std::vector<Key> & keys) const1448 int SQLiteSingleVerStorageExecutor::GetAllKeys(sqlite3_stmt *statement, std::vector<Key> &keys) const
1449 {
1450 if (statement == nullptr) {
1451 return -E_INVALID_DB;
1452 }
1453 int errCode;
1454 do {
1455 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1456 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1457 Key key;
1458 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, key);
1459 if (errCode != E_OK) {
1460 break;
1461 }
1462
1463 keys.push_back(std::move(key));
1464 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1465 errCode = E_OK;
1466 break;
1467 } else {
1468 LOGE("SQLite step for getting all keys failed:%d", errCode);
1469 break;
1470 }
1471 } while (true);
1472
1473 return errCode;
1474 }
1475
BindSavedSyncData(sqlite3_stmt * statement,const DataItem & dataItem,const Key & hashKey,const SyncDataDevices & devices,bool isUpdate)1476 int SQLiteSingleVerStorageExecutor::BindSavedSyncData(sqlite3_stmt *statement, const DataItem &dataItem,
1477 const Key &hashKey, const SyncDataDevices &devices, bool isUpdate)
1478 {
1479 const int hashKeyIndex = isUpdate ? BIND_SYNC_UPDATE_HASH_KEY_INDEX : BIND_SYNC_HASH_KEY_INDEX;
1480 int errCode = SQLiteUtils::BindBlobToStatement(statement, hashKeyIndex, hashKey, false);
1481 if (errCode != E_OK) {
1482 LOGE("Bind saved sync data hash key failed:%d", errCode);
1483 return errCode;
1484 }
1485
1486 // if delete flag is set, just use the hash key instead of the key
1487 if ((dataItem.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG) {
1488 errCode = SQLiteUtils::MapSQLiteErrno(sqlite3_bind_zeroblob(statement, BIND_SYNC_KEY_INDEX, -1));
1489 } else {
1490 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_KEY_INDEX, dataItem.key, false);
1491 }
1492
1493 if (errCode != E_OK) {
1494 LOGE("Bind saved sync data key failed:%d", errCode);
1495 return errCode;
1496 }
1497
1498 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_VAL_INDEX, dataItem.value, true);
1499 if (errCode != E_OK) {
1500 LOGE("Bind saved sync data value failed:%d", errCode);
1501 return errCode;
1502 }
1503
1504 errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_SYNC_STAMP_INDEX, dataItem.timestamp);
1505 if (errCode != E_OK) {
1506 LOGE("Bind saved sync data stamp failed:%d", errCode);
1507 return errCode;
1508 }
1509
1510 const int writeTimeIndex = isUpdate ? BIND_SYNC_UPDATE_W_TIME_INDEX : BIND_SYNC_W_TIME_INDEX;
1511 errCode = SQLiteUtils::BindInt64ToStatement(statement, writeTimeIndex, dataItem.writeTimestamp);
1512 LOGD("Write timestamp:%" PRIu64 " timestamp:%" PRIu64 ", %" PRIu64,
1513 dataItem.writeTimestamp, dataItem.timestamp, dataItem.flag);
1514 if (errCode != E_OK) {
1515 LOGE("Bind saved sync data write stamp failed:%d", errCode);
1516 return errCode;
1517 }
1518
1519 return BindDevForSavedSyncData(statement, dataItem, devices.origDev, devices.dev);
1520 }
1521
PutConflictData(const DataItem & itemPut,const DataItem & itemGet,const DeviceInfo & deviceInfo,const DataOperStatus & dataStatus,SingleVerNaturalStoreCommitNotifyData * commitData)1522 void SQLiteSingleVerStorageExecutor::PutConflictData(const DataItem &itemPut, const DataItem &itemGet,
1523 const DeviceInfo &deviceInfo, const DataOperStatus &dataStatus,
1524 SingleVerNaturalStoreCommitNotifyData *commitData)
1525 {
1526 if (commitData == nullptr) {
1527 return;
1528 }
1529
1530 bool conflictNotifyMatch = commitData->IsConflictedNotifyMatched(itemPut, itemGet);
1531 if (!conflictNotifyMatch) {
1532 return;
1533 }
1534
1535 if (dataStatus.preStatus == DataStatus::NOEXISTED ||
1536 ((dataStatus.preStatus == DataStatus::DELETED) && dataStatus.isDeleted)) {
1537 return;
1538 }
1539
1540 Key origKey;
1541 if ((itemPut.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
1542 (itemPut.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) {
1543 origKey = itemGet.key;
1544 } else {
1545 origKey = itemPut.key;
1546 }
1547
1548 // insert db original entry
1549 std::vector<uint8_t> getDevVect(itemGet.dev.begin(), itemGet.dev.end());
1550 DataItemInfo orgItemInfo = {itemGet, true, getDevVect};
1551 orgItemInfo.dataItem.key = origKey;
1552 commitData->InsertConflictedItem(orgItemInfo, true);
1553
1554 // insert conflict entry
1555 std::string putDeviceName = DBCommon::TransferHashString(deviceInfo.deviceName);
1556 std::vector<uint8_t> putDevVect(putDeviceName.begin(), putDeviceName.end());
1557
1558 DataItemInfo newItemInfo = {itemPut, deviceInfo.isLocal, putDevVect};
1559 newItemInfo.dataItem.key = origKey;
1560 commitData->InsertConflictedItem(newItemInfo, false);
1561 }
1562
Reset()1563 int SQLiteSingleVerStorageExecutor::Reset()
1564 {
1565 if (isTransactionOpen_) {
1566 Rollback();
1567 }
1568
1569 int errCode = ResetForSavingData(SingleVerDataType::SYNC_TYPE);
1570 if (errCode != E_OK) {
1571 LOGE("Finalize the sync resources for saving sync data failed: %d", errCode);
1572 }
1573
1574 errCode = ResetForSavingData(SingleVerDataType::LOCAL_TYPE);
1575 if (errCode != E_OK) {
1576 LOGE("Finalize the local resources for saving sync data failed: %d", errCode);
1577 }
1578 return SQLiteStorageExecutor::Reset();
1579 }
1580
GetSyncDataItemPre(const DataItem & itemPut,DataItem & itemGet,Key & hashKey) const1581 int SQLiteSingleVerStorageExecutor::GetSyncDataItemPre(const DataItem &itemPut, DataItem &itemGet,
1582 Key &hashKey) const
1583 {
1584 if (isSyncMigrating_) {
1585 hashKey = itemPut.hashKey;
1586 } else if ((itemPut.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
1587 ((itemPut.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY)) {
1588 hashKey = itemPut.key;
1589 } else {
1590 int errCode = DBCommon::CalcValueHash(itemPut.key, hashKey);
1591 if (errCode != E_OK) {
1592 return errCode;
1593 }
1594 }
1595
1596 return GetSyncDataPreByHashKey(hashKey, itemGet);
1597 }
1598
GetSyncDataPreByHashKey(const Key & hashKey,DataItem & itemGet) const1599 int SQLiteSingleVerStorageExecutor::GetSyncDataPreByHashKey(const Key &hashKey, DataItem &itemGet) const
1600 {
1601 auto statement = isSyncMigrating_ ? migrateSyncStatements_.queryStatement : saveSyncStatements_.queryStatement;
1602 int errCode = SQLiteUtils::BindBlobToStatement(statement, 1, hashKey, false); // 1st arg.
1603 if (errCode != E_OK) {
1604 return errCode;
1605 }
1606
1607 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1608 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // no find the key
1609 errCode = -E_NOT_FOUND;
1610 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1611 itemGet.timestamp = static_cast<Timestamp>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
1612 itemGet.writeTimestamp = static_cast<Timestamp>(sqlite3_column_int64(statement, SYNC_RES_W_TIME_INDEX));
1613 itemGet.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
1614 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, itemGet.key);
1615 if (errCode != E_OK) {
1616 return errCode;
1617 }
1618 std::vector<uint8_t> devVect;
1619 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_DEVICE_INDEX, devVect);
1620 if (errCode != E_OK) {
1621 return errCode;
1622 }
1623
1624 std::vector<uint8_t> origDevVect;
1625 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_ORI_DEV_INDEX, origDevVect);
1626 if (errCode != E_OK) {
1627 return errCode;
1628 }
1629 itemGet.dev.assign(devVect.begin(), devVect.end());
1630 itemGet.origDev.assign(origDevVect.begin(), origDevVect.end());
1631 }
1632 return errCode;
1633 }
1634
DeleteLocalDataInner(SingleVerNaturalStoreCommitNotifyData * committedData,const Key & key,const Value & value)1635 int SQLiteSingleVerStorageExecutor::DeleteLocalDataInner(SingleVerNaturalStoreCommitNotifyData *committedData,
1636 const Key &key, const Value &value)
1637 {
1638 if (committedData != nullptr) {
1639 Key hashKey;
1640 int innerErrCode = DBCommon::CalcValueHash(key, hashKey);
1641 if (innerErrCode != E_OK) {
1642 return innerErrCode;
1643 }
1644 committedData->InitKeyPropRecord(hashKey, ExistStatus::EXIST);
1645 }
1646
1647 std::string sql = DELETE_LOCAL_SQL;
1648 if (executorState_ == ExecutorState::CACHE_ATTACH_MAIN) {
1649 sql = DELETE_LOCAL_SQL_FROM_CACHEHANDLE;
1650 }
1651 sqlite3_stmt *statement = nullptr;
1652 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
1653 if (errCode != E_OK) {
1654 goto ERROR;
1655 }
1656
1657 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, key, false);
1658 if (errCode != E_OK) {
1659 LOGE("Bind the key error(%d) when delete kv data.", errCode);
1660 goto ERROR;
1661 }
1662
1663 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1664 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1665 if (sqlite3_changes(dbHandle_) > 0) {
1666 if (committedData != nullptr) {
1667 Entry entry = {key, value};
1668 committedData->InsertCommittedData(std::move(entry), DataType::DELETE, true);
1669 } else {
1670 LOGE("DeleteLocalKvData failed to do commit notify because of OOM.");
1671 }
1672 errCode = E_OK;
1673 }
1674 }
1675
1676 ERROR:
1677 SQLiteUtils::ResetStatement(statement, true, errCode);
1678 return CheckCorruptedStatus(errCode);
1679 }
1680
DeleteLocalKvData(const Key & key,SingleVerNaturalStoreCommitNotifyData * committedData,Value & value,Timestamp & timestamp)1681 int SQLiteSingleVerStorageExecutor::DeleteLocalKvData(const Key &key,
1682 SingleVerNaturalStoreCommitNotifyData *committedData, Value &value, Timestamp ×tamp)
1683 {
1684 int errCode = GetKvData(SingleVerDataType::LOCAL_TYPE, key, value, timestamp);
1685 if (errCode != E_OK) {
1686 return CheckCorruptedStatus(errCode);
1687 }
1688
1689 return DeleteLocalDataInner(committedData, key, value);
1690 }
1691
EraseSyncData(const Key & hashKey)1692 int SQLiteSingleVerStorageExecutor::EraseSyncData(const Key &hashKey)
1693 {
1694 sqlite3_stmt *stmt = nullptr;
1695 std::string sql = (executorState_ == ExecutorState::CACHE_ATTACH_MAIN) ?
1696 DELETE_SYNC_DATA_WITH_HASHKEY_FROM_CACHEHANDLE : DELETE_SYNC_DATA_WITH_HASHKEY;
1697 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, stmt);
1698 if (errCode != E_OK) {
1699 LOGE("get erase statement failed:%d", errCode);
1700 return errCode;
1701 }
1702
1703 errCode = SQLiteUtils::BindBlobToStatement(stmt, 1, hashKey, false);
1704 if (errCode != E_OK) {
1705 LOGE("bind hashKey failed:%d", errCode);
1706 goto END;
1707 }
1708
1709 errCode = SQLiteUtils::StepWithRetry(stmt, false);
1710 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1711 errCode = E_OK;
1712 } else {
1713 LOGE("erase data failed:%d", errCode);
1714 }
1715 END:
1716 SQLiteUtils::ResetStatement(stmt, true, errCode);
1717 return CheckCorruptedStatus(errCode);
1718 }
1719
RemoveDeviceData(const std::string & deviceName)1720 int SQLiteSingleVerStorageExecutor::RemoveDeviceData(const std::string &deviceName)
1721 {
1722 // Transfer the device name.
1723 std::string devName = DBCommon::TransferHashString(deviceName);
1724 sqlite3_stmt *statement = nullptr;
1725 std::vector<uint8_t> devVect(devName.begin(), devName.end());
1726
1727 int errCode = SQLiteUtils::GetStatement(dbHandle_, REMOVE_DEV_DATA_SQL, statement);
1728 if (errCode != E_OK) {
1729 goto ERROR;
1730 }
1731
1732 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, devVect, true); // only one arg.
1733 if (errCode != E_OK) {
1734 LOGE("Failed to bind the removed device:%d", errCode);
1735 goto ERROR;
1736 }
1737
1738 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1739 if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1740 LOGE("Failed to execute rm the device synced data:%d", errCode);
1741 } else {
1742 errCode = E_OK;
1743 }
1744
1745 ERROR:
1746 SQLiteUtils::ResetStatement(statement, true, errCode);
1747 return CheckCorruptedStatus(errCode);
1748 }
1749
StepForResultEntries(sqlite3_stmt * statement,std::vector<Entry> & entries) const1750 int SQLiteSingleVerStorageExecutor::StepForResultEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const
1751 {
1752 entries.clear();
1753 entries.shrink_to_fit();
1754 Entry entry;
1755 int errCode = E_OK;
1756 do {
1757 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1758 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1759 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, entry.key);
1760 if (errCode != E_OK) {
1761 return errCode;
1762 }
1763
1764 errCode = SQLiteUtils::GetColumnBlobValue(statement, 1, entry.value);
1765 if (errCode != E_OK) {
1766 return errCode;
1767 }
1768
1769 entries.push_back(std::move(entry));
1770 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1771 errCode = E_OK;
1772 break;
1773 } else {
1774 LOGE("SQLite step failed:%d", errCode);
1775 return errCode;
1776 }
1777 } while (true);
1778
1779 // if select no result, return the -E_NOT_FOUND.
1780 if (entries.empty()) {
1781 errCode = -E_NOT_FOUND;
1782 }
1783
1784 return errCode;
1785 }
1786
BindDevForSavedSyncData(sqlite3_stmt * statement,const DataItem & dataItem,const std::string & origDev,const std::string & deviceName)1787 int SQLiteSingleVerStorageExecutor::BindDevForSavedSyncData(sqlite3_stmt *statement, const DataItem &dataItem,
1788 const std::string &origDev, const std::string &deviceName)
1789 {
1790 int errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_SYNC_FLAG_INDEX,
1791 static_cast<int64_t>(dataItem.flag));
1792 if (errCode != E_OK) {
1793 LOGE("Bind saved sync data flag failed:%d", errCode);
1794 return errCode;
1795 }
1796
1797 std::vector<uint8_t> devVect(deviceName.begin(), deviceName.end());
1798 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_DEV_INDEX, devVect, true);
1799 if (errCode != E_OK) {
1800 LOGE("Bind dev for sync data failed:%d", errCode);
1801 return errCode;
1802 }
1803
1804 std::vector<uint8_t> origDevVect(origDev.begin(), origDev.end());
1805 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_ORI_DEV_INDEX, origDevVect, true);
1806 if (errCode != E_OK) {
1807 LOGE("Bind orig dev for sync data failed:%d", errCode);
1808 }
1809
1810 return errCode;
1811 }
1812
GetDataItemSerialSize(const DataItem & item,size_t appendLen)1813 size_t SQLiteSingleVerStorageExecutor::GetDataItemSerialSize(const DataItem &item, size_t appendLen)
1814 {
1815 // timestamp and local flag: 3 * uint64_t, version(uint32_t), key, value, origin dev and the padding size.
1816 // the size would not be very large.
1817 static const size_t maxOrigDevLength = 40;
1818 size_t devLength = std::max(maxOrigDevLength, item.origDev.size());
1819 size_t dataSize = (Parcel::GetUInt64Len() * 3 + Parcel::GetUInt32Len() + Parcel::GetVectorCharLen(item.key) +
1820 Parcel::GetVectorCharLen(item.value) + devLength + appendLen);
1821
1822 return dataSize;
1823 }
1824
InitResultSet(const Key & keyPrefix,sqlite3_stmt * & countStmt)1825 int SQLiteSingleVerStorageExecutor::InitResultSet(const Key &keyPrefix, sqlite3_stmt *&countStmt)
1826 {
1827 if (dbHandle_ == nullptr) {
1828 return -E_INVALID_DB;
1829 }
1830 // bind statement for count
1831 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_COUNT_SYNC_PREFIX_SQL, countStmt);
1832 if (errCode != E_OK) {
1833 LOGE("Get count statement for resultset error:%d", errCode);
1834 return errCode;
1835 }
1836
1837 errCode = SQLiteUtils::BindPrefixKey(countStmt, 1, keyPrefix); // first argument is key
1838 if (errCode != E_OK) {
1839 LOGE("Bind count key error:%d", errCode);
1840 goto ERROR;
1841 }
1842 // bind statement for result set
1843 errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_ROWID_PREFIX_SQL, getResultRowIdStatement_);
1844 if (errCode != E_OK) {
1845 LOGE("Get result set rowid statement error:%d", errCode);
1846 goto ERROR;
1847 }
1848
1849 errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_DATA_BY_ROWID_SQL, getResultEntryStatement_);
1850 if (errCode != E_OK) {
1851 LOGE("Get result set entry statement error:%d", errCode);
1852 goto ERROR;
1853 }
1854
1855 errCode = SQLiteUtils::BindPrefixKey(getResultRowIdStatement_, 1, keyPrefix); // first argument is key
1856 if (errCode != E_OK) {
1857 LOGE("Bind result set rowid statement error:%d", errCode);
1858 goto ERROR;
1859 }
1860 return E_OK;
1861
1862 ERROR:
1863 SQLiteUtils::ResetStatement(countStmt, true, errCode);
1864 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
1865 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
1866 return CheckCorruptedStatus(errCode);
1867 }
1868
InitResultSetCount(QueryObject & queryObj,sqlite3_stmt * & countStmt)1869 int SQLiteSingleVerStorageExecutor::InitResultSetCount(QueryObject &queryObj, sqlite3_stmt *&countStmt)
1870 {
1871 if (dbHandle_ == nullptr) {
1872 return -E_INVALID_DB;
1873 }
1874
1875 int errCode = E_OK;
1876 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
1877 if (errCode != E_OK) {
1878 return errCode;
1879 }
1880
1881 errCode = helper.GetCountSqlStatement(dbHandle_, countStmt);
1882 if (errCode != E_OK) {
1883 LOGE("Get count bind statement error:%d", errCode);
1884 SQLiteUtils::ResetStatement(countStmt, true, errCode);
1885 }
1886 return errCode;
1887 }
1888
InitResultSetContent(QueryObject & queryObj)1889 int SQLiteSingleVerStorageExecutor::InitResultSetContent(QueryObject &queryObj)
1890 {
1891 int errCode = E_OK;
1892 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
1893 if (errCode != E_OK) {
1894 return errCode;
1895 }
1896
1897 // bind statement for result set
1898 errCode = helper.GetQuerySqlStatement(dbHandle_, true, getResultRowIdStatement_);
1899 if (errCode != E_OK) {
1900 LOGE("[SqlSinExe][InitResSetContent] Bind result set rowid statement of query error:%d", errCode);
1901 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
1902 return errCode;
1903 }
1904 errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_DATA_BY_ROWID_SQL, getResultEntryStatement_);
1905 if (errCode != E_OK) {
1906 LOGE("[SqlSinExe][InitResSetContent] Get result set entry statement of query error:%d", errCode);
1907 return CheckCorruptedStatus(errCode);
1908 }
1909 return errCode;
1910 }
1911
InitResultSet(QueryObject & queryObj,sqlite3_stmt * & countStmt)1912 int SQLiteSingleVerStorageExecutor::InitResultSet(QueryObject &queryObj, sqlite3_stmt *&countStmt)
1913 {
1914 if (dbHandle_ == nullptr) {
1915 return -E_INVALID_DB;
1916 }
1917
1918 int errCode = E_OK;
1919 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
1920 if (errCode != E_OK) {
1921 return errCode;
1922 }
1923
1924 if (!queryObj.IsValid()) {
1925 return -E_INVALID_QUERY_FORMAT;
1926 }
1927
1928 errCode = InitResultSetCount(queryObj, countStmt);
1929 if (errCode != E_OK) {
1930 return CheckCorruptedStatus(errCode);
1931 }
1932
1933 errCode = InitResultSetContent(queryObj);
1934 if (errCode != E_OK) {
1935 SQLiteUtils::ResetStatement(countStmt, true, errCode);
1936 }
1937 return CheckCorruptedStatus(errCode);
1938 }
1939
UpdateLocalDataTimestamp(Timestamp timestamp)1940 int SQLiteSingleVerStorageExecutor::UpdateLocalDataTimestamp(Timestamp timestamp)
1941 {
1942 const std::string updateSql = "UPDATE local_data SET timestamp=";
1943 std::string sql = updateSql + std::to_string(timestamp) + " WHERE timestamp=0;";
1944 int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
1945 return CheckCorruptedStatus(errCode);
1946 }
1947
SetAttachMetaMode(bool attachMetaMode)1948 void SQLiteSingleVerStorageExecutor::SetAttachMetaMode(bool attachMetaMode)
1949 {
1950 attachMetaMode_ = attachMetaMode;
1951 }
1952
GetOneRawDataItem(sqlite3_stmt * statement,DataItem & dataItem,uint64_t & verInCurCacheDb,bool isCacheDb) const1953 int SQLiteSingleVerStorageExecutor::GetOneRawDataItem(sqlite3_stmt *statement, DataItem &dataItem,
1954 uint64_t &verInCurCacheDb, bool isCacheDb) const
1955 {
1956 int errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, dataItem.key);
1957 if (errCode != E_OK) {
1958 return errCode;
1959 }
1960
1961 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_VAL_INDEX, dataItem.value);
1962 if (errCode != E_OK) {
1963 return errCode;
1964 }
1965
1966 dataItem.timestamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
1967 dataItem.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
1968
1969 std::vector<uint8_t> devVect;
1970 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_DEVICE_INDEX, devVect);
1971 if (errCode != E_OK) {
1972 return errCode;
1973 }
1974 dataItem.dev = std::string(devVect.begin(), devVect.end());
1975
1976 devVect.clear();
1977 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_ORI_DEV_INDEX, devVect);
1978 if (errCode != E_OK) {
1979 return errCode;
1980 }
1981 dataItem.origDev = std::string(devVect.begin(), devVect.end());
1982
1983 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_HASH_KEY_INDEX, dataItem.hashKey);
1984 if (errCode != E_OK) {
1985 return errCode;
1986 }
1987 dataItem.writeTimestamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_W_TIME_INDEX));
1988 if (errCode != E_OK) {
1989 return errCode;
1990 }
1991 if (isCacheDb) {
1992 verInCurCacheDb = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_VERSION_INDEX));
1993 }
1994 return E_OK;
1995 }
1996
GetAllDataItems(sqlite3_stmt * statement,std::vector<DataItem> & dataItems,uint64_t & verInCurCacheDb,bool isCacheDb) const1997 int SQLiteSingleVerStorageExecutor::GetAllDataItems(sqlite3_stmt *statement, std::vector<DataItem> &dataItems,
1998 uint64_t &verInCurCacheDb, bool isCacheDb) const
1999 {
2000 dataItems.clear();
2001 dataItems.shrink_to_fit();
2002 DataItem dataItem;
2003 int errCode;
2004 do {
2005 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
2006 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
2007 errCode = GetOneRawDataItem(statement, dataItem, verInCurCacheDb, isCacheDb);
2008 if (errCode != E_OK) {
2009 return errCode;
2010 }
2011 dataItems.push_back(std::move(dataItem));
2012 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
2013 errCode = E_OK;
2014 break;
2015 } else {
2016 LOGE("SQLite step failed:%d", errCode);
2017 break;
2018 }
2019 } while (true);
2020
2021 return CheckCorruptedStatus(errCode);
2022 }
2023
OpenResultSetForCacheRowIdModeCommon(std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,int & count)2024 int SQLiteSingleVerStorageExecutor::OpenResultSetForCacheRowIdModeCommon(std::vector<int64_t> &rowIdCache,
2025 uint32_t cacheLimit, int &count)
2026 {
2027 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_DATA_BY_ROWID_SQL, getResultEntryStatement_);
2028 if (errCode != E_OK) {
2029 LOGE("[SqlSinExe][OpenResSetRowId][Common] Get entry stmt fail, errCode=%d", errCode);
2030 return CheckCorruptedStatus(errCode);
2031 }
2032 errCode = StartTransaction(TransactType::DEFERRED);
2033 if (errCode != E_OK) {
2034 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
2035 return CheckCorruptedStatus(errCode);
2036 }
2037 // Now Ready To Execute
2038 errCode = ResultSetLoadRowIdCache(rowIdCache, cacheLimit, 0, count);
2039 if (errCode != E_OK) {
2040 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
2041 Rollback();
2042 return CheckCorruptedStatus(errCode);
2043 }
2044 // Consider finalize getResultRowIdStatement_ here if count equal to size of rowIdCache.
2045 return E_OK;
2046 }
2047
ResultSetLoadRowIdCache(std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,uint32_t cacheStartPos,int & count)2048 int SQLiteSingleVerStorageExecutor::ResultSetLoadRowIdCache(std::vector<int64_t> &rowIdCache, uint32_t cacheLimit,
2049 uint32_t cacheStartPos, int &count)
2050 {
2051 rowIdCache.clear();
2052 count = 0;
2053 while (true) {
2054 int errCode = SQLiteUtils::StepWithRetry(getResultRowIdStatement_, isMemDb_);
2055 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
2056 if (count >= static_cast<int>(cacheStartPos) && rowIdCache.size() < cacheLimit) {
2057 // If we can start cache, and, if we can still cache
2058 int64_t rowid = sqlite3_column_int64(getResultRowIdStatement_, 0);
2059 rowIdCache.push_back(rowid);
2060 }
2061 // Always increase the count
2062 count++;
2063 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
2064 break;
2065 } else {
2066 LOGE("[SqlSinExe][ResSetLoadCache] Step fail, errCode=%d", errCode);
2067 rowIdCache.clear();
2068 count = 0;
2069 return CheckCorruptedStatus(errCode);
2070 }
2071 }
2072 return E_OK;
2073 }
2074
ResetStatement()2075 int SQLiteSingleVerStorageExecutor::SaveRecordStatements::ResetStatement()
2076 {
2077 int errCode = E_OK;
2078 SQLiteUtils::ResetStatement(insertStatement, true, errCode);
2079 if (errCode != E_OK) {
2080 LOGE("Finalize insert statements failed, error: %d", errCode);
2081 }
2082
2083 SQLiteUtils::ResetStatement(updateStatement, true, errCode);
2084 if (errCode != E_OK) {
2085 LOGE("Finalize update statements failed, error: %d", errCode);
2086 }
2087
2088 SQLiteUtils::ResetStatement(queryStatement, true, errCode);
2089 if (errCode != E_OK) {
2090 LOGE("Finalize query statement failed, error: %d", errCode);
2091 }
2092 return errCode;
2093 }
2094
FinalizeAllStatements()2095 void SQLiteSingleVerStorageExecutor::FinalizeAllStatements()
2096 {
2097 int errCode = saveLocalStatements_.ResetStatement();
2098 if (errCode != E_OK) {
2099 LOGE("Finalize saveLocal statements failed, error: %d", errCode);
2100 }
2101
2102 errCode = saveSyncStatements_.ResetStatement();
2103 if (errCode != E_OK) {
2104 LOGE("Finalize saveSync statement failed, error: %d", errCode);
2105 }
2106
2107 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
2108 if (errCode != E_OK) {
2109 LOGE("Finalize getResultRowIdStatement_ failed, error: %d", errCode);
2110 }
2111
2112 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
2113 if (errCode != E_OK) {
2114 LOGE("Finalize getResultEntryStatement_ failed, error: %d", errCode);
2115 }
2116
2117 errCode = migrateSyncStatements_.ResetStatement();
2118 if (errCode != E_OK) {
2119 LOGE("Finalize migrateSync statements failed, error: %d", errCode);
2120 }
2121
2122 ReleaseContinueStatement();
2123 }
2124
SetConflictResolvePolicy(int policy)2125 void SQLiteSingleVerStorageExecutor::SetConflictResolvePolicy(int policy)
2126 {
2127 if (policy == DENY_OTHER_DEV_AMEND_CUR_DEV_DATA || policy == DEFAULT_LAST_WIN) {
2128 conflictResolvePolicy_ = policy;
2129 }
2130 }
2131
CheckIntegrity() const2132 int SQLiteSingleVerStorageExecutor::CheckIntegrity() const
2133 {
2134 if (dbHandle_ == nullptr) {
2135 return -E_INVALID_DB;
2136 }
2137
2138 return SQLiteUtils::CheckIntegrity(dbHandle_, CHECK_DB_INTEGRITY_SQL);
2139 }
2140
ForceCheckPoint() const2141 int SQLiteSingleVerStorageExecutor::ForceCheckPoint() const
2142 {
2143 if (dbHandle_ == nullptr) {
2144 return -E_INVALID_DB;
2145 }
2146 SQLiteUtils::ExecuteCheckPoint(dbHandle_);
2147 return E_OK;
2148 }
2149
GetLogFileSize() const2150 uint64_t SQLiteSingleVerStorageExecutor::GetLogFileSize() const
2151 {
2152 if (isMemDb_) {
2153 return 0;
2154 }
2155
2156 const char *fileName = sqlite3_db_filename(dbHandle_, "main");
2157 if (fileName == nullptr) {
2158 return 0;
2159 }
2160 std::string walName = std::string(fileName) + "-wal";
2161 uint64_t fileSize = 0;
2162 int result = OS::CalFileSize(std::string(walName), fileSize);
2163 if (result != E_OK) {
2164 return 0;
2165 }
2166 return fileSize;
2167 }
2168 } // namespace DistributedDB
2169