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 &timeStamp) 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 } else {
502 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
503 LOGD("Get sync data finished, size of packet:%zu, number of item:%zu", dataTotalSize, dataItems.size());
504 errCode = -E_FINISHED;
505 } else {
506 LOGE("Get sync data error:%d", errCode);
507 }
508 break;
509 }
510
511 // If dataTotalSize value is bigger than blockSize value , reserve the surplus data item.
512 dataTotalSize += GetDataItemSerialSize(dataItem, appendLength);
513 if ((dataTotalSize > dataSizeInfo.blockSize && !dataItems.empty()) ||
514 dataItems.size() >= dataSizeInfo.packetSize) {
515 errCode = -E_UNFINISHED;
516 break;
517 } else {
518 dataItems.push_back(std::move(dataItem));
519 }
520 } while (true);
521 return errCode;
522 }
523
GetSyncDataByTimestamp(std::vector<DataItem> & dataItems,size_t appendLength,TimeStamp begin,TimeStamp end,const DataSizeSpecInfo & dataSizeInfo) const524 int SQLiteSingleVerStorageExecutor::GetSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength,
525 TimeStamp begin, TimeStamp end, const DataSizeSpecInfo &dataSizeInfo) const
526 {
527 sqlite3_stmt *statement = nullptr;
528 int errCode = PrepareForSyncDataByTime(begin, end, statement);
529 if (errCode != E_OK) {
530 return errCode;
531 }
532
533 errCode = GetSyncDataItems(dataItems, statement, appendLength, dataSizeInfo);
534 SQLiteUtils::ResetStatement(statement, true, errCode);
535 return CheckCorruptedStatus(errCode);
536 }
537
GetDeletedSyncDataByTimestamp(std::vector<DataItem> & dataItems,size_t appendLength,TimeStamp begin,TimeStamp end,const DataSizeSpecInfo & dataSizeInfo) const538 int SQLiteSingleVerStorageExecutor::GetDeletedSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength,
539 TimeStamp begin, TimeStamp end, const DataSizeSpecInfo &dataSizeInfo) const
540 {
541 sqlite3_stmt *statement = nullptr;
542 int errCode = PrepareForSyncDataByTime(begin, end, statement, true);
543 if (errCode != E_OK) {
544 return errCode;
545 }
546
547 errCode = GetSyncDataItems(dataItems, statement, appendLength, dataSizeInfo);
548 SQLiteUtils::ResetStatement(statement, true, errCode);
549 return CheckCorruptedStatus(errCode);
550 }
551
552 namespace {
AppendDataItem(std::vector<DataItem> & dataItems,const DataItem & item,size_t & dataTotalSize,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo)553 int AppendDataItem(std::vector<DataItem> &dataItems, const DataItem &item, size_t &dataTotalSize, size_t appendLength,
554 const DataSizeSpecInfo &dataSizeInfo)
555 {
556 // If dataTotalSize value is bigger than blockSize value , reserve the surplus data item.
557 dataTotalSize += SQLiteSingleVerStorageExecutor::GetDataItemSerialSize(item, appendLength);
558 if ((dataTotalSize > dataSizeInfo.blockSize && !dataItems.empty()) ||
559 dataItems.size() >= dataSizeInfo.packetSize) {
560 return -E_UNFINISHED;
561 } else {
562 dataItems.push_back(item);
563 }
564 return E_OK;
565 }
566
GetFullDataStatement(sqlite3 * db,const std::pair<TimeStamp,TimeStamp> & timeRange,sqlite3_stmt * & stmt)567 int GetFullDataStatement(sqlite3 *db, const std::pair<TimeStamp, TimeStamp> &timeRange, sqlite3_stmt *&stmt)
568 {
569 int errCode = SQLiteUtils::GetStatement(db, SELECT_SYNC_MODIFY_SQL, stmt);
570 if (errCode != E_OK) {
571 LOGE("Get statement failed. %d", errCode);
572 return errCode;
573 }
574 errCode = SQLiteUtils::BindInt64ToStatement(stmt, 1, timeRange.first); // 1 : Bind time rang index start
575 if (errCode != E_OK) {
576 LOGE("Bind time range to statement failed. %d", errCode);
577 goto ERR;
578 }
579 errCode = SQLiteUtils::BindInt64ToStatement(stmt, 2, timeRange.second); // 2 : Bind time rang index end
580 if (errCode != E_OK) {
581 LOGE("Bind time range to statement failed. %d", errCode);
582 goto ERR;
583 }
584 return E_OK; // do not release statement when success
585 ERR:
586 SQLiteUtils::ResetStatement(stmt, true, errCode);
587 return errCode;
588 }
589
GetQueryDataStatement(sqlite3 * db,QueryObject query,const std::pair<TimeStamp,TimeStamp> & timeRange,sqlite3_stmt * & stmt)590 int GetQueryDataStatement(sqlite3 *db, QueryObject query, const std::pair<TimeStamp, TimeStamp> &timeRange,
591 sqlite3_stmt *&stmt)
592 {
593 int errCode = E_OK;
594 SqliteQueryHelper helper = query.GetQueryHelper(errCode);
595 if (errCode != E_OK) {
596 return errCode;
597 }
598 return helper.GetQuerySyncStatement(db, timeRange.first, timeRange.second, stmt);
599 }
600
GetNextDataItem(sqlite3_stmt * stmt,bool isMemDB,DataItem & item)601 int GetNextDataItem(sqlite3_stmt *stmt, bool isMemDB, DataItem &item)
602 {
603 int errCode = SQLiteUtils::StepWithRetry(stmt, isMemDB);
604 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
605 errCode = GetDataItemForSync(stmt, item);
606 }
607 return errCode;
608 }
609 }
610
GetSyncDataWithQuery(const QueryObject & query,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo,const std::pair<TimeStamp,TimeStamp> & timeRange,std::vector<DataItem> & dataItems) const611 int SQLiteSingleVerStorageExecutor::GetSyncDataWithQuery(const QueryObject &query, size_t appendLength,
612 const DataSizeSpecInfo &dataSizeInfo, const std::pair<TimeStamp, TimeStamp> &timeRange,
613 std::vector<DataItem> &dataItems) const
614 {
615 sqlite3_stmt *fullStmt = nullptr; // statement for get all modified data in the time range
616 sqlite3_stmt *queryStmt = nullptr; // statement for get modified data which is matched query in the time range
617 int errCode = GetQueryDataStatement(dbHandle_, query, timeRange, queryStmt);
618 if (errCode != E_OK) {
619 LOGE("Get query matched data statement failed. %d", errCode);
620 goto END;
621 }
622 if (query.IsQueryOnlyByKey()) {
623 // Query sync by prefixKey only should not deal with REMOTE_DEVICE_DATA_MISS_QUERY. Get the data directly.
624 errCode = GetSyncDataItems(dataItems, queryStmt, appendLength, dataSizeInfo);
625 goto END;
626 }
627 errCode = GetFullDataStatement(dbHandle_, timeRange, fullStmt);
628 if (errCode != E_OK) {
629 LOGE("Get full changed data statement failed. %d", errCode);
630 goto END;
631 }
632 errCode = GetSyncDataWithQuery(fullStmt, queryStmt, appendLength, dataSizeInfo, dataItems);
633 if (errCode != E_OK && errCode != -E_UNFINISHED && errCode != -E_FINISHED) {
634 LOGE("Get sync data with query failed. %d", errCode);
635 }
636 END:
637 SQLiteUtils::ResetStatement(fullStmt, true, errCode);
638 SQLiteUtils::ResetStatement(queryStmt, true, errCode);
639 return CheckCorruptedStatus(errCode);
640 }
641
GetSyncDataWithQuery(sqlite3_stmt * fullStmt,sqlite3_stmt * queryStmt,size_t appendLength,const DataSizeSpecInfo & dataSizeInfo,std::vector<DataItem> & dataItems) const642 int SQLiteSingleVerStorageExecutor::GetSyncDataWithQuery(sqlite3_stmt *fullStmt, sqlite3_stmt *queryStmt,
643 size_t appendLength, const DataSizeSpecInfo &dataSizeInfo, std::vector<DataItem> &dataItems) const
644 {
645 int errCode = E_OK;
646 size_t dataTotalSize = 0;
647 DataItem fullItem;
648 DataItem matchItem;
649 bool isFullItemFinished = false;
650 bool isMatchItemFinished = false;
651 while (!isFullItemFinished || !isMatchItemFinished) {
652 errCode = GetNextDataItem(queryStmt, isMemDb_, matchItem);
653 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // query finished
654 isMatchItemFinished = true;
655 } else if (errCode != E_OK) { // step failed or get data failed
656 LOGE("Get next query matched data failed. %d", errCode);
657 return errCode;
658 }
659 while (!isFullItemFinished) {
660 errCode = GetNextDataItem(fullStmt, isMemDb_, fullItem);
661 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // queryStmt is a subset of fullStmt
662 isFullItemFinished = true;
663 break;
664 } else if (errCode != E_OK) { // step failed or get data failed
665 LOGE("Get next changed data failed. %d", errCode);
666 return errCode;
667 }
668 if (!isMatchItemFinished && matchItem.key == fullItem.key) {
669 errCode = AppendDataItem(dataItems, matchItem, dataTotalSize, appendLength, dataSizeInfo);
670 if (errCode == -E_UNFINISHED) {
671 goto END;
672 }
673 break; // step to next match data
674 } else {
675 DBCommon::CalcValueHash(fullItem.key, fullItem.key);
676 Value().swap(fullItem.value); // not send value when data miss query
677 fullItem.flag |= DataItem::REMOTE_DEVICE_DATA_MISS_QUERY;
678 errCode = AppendDataItem(dataItems, fullItem, dataTotalSize, appendLength, dataSizeInfo);
679 if (errCode == -E_UNFINISHED) {
680 goto END;
681 }
682 }
683 }
684 }
685 END:
686 LOGD("Get sync data finished, size of packet:%zu, number of item:%zu", dataTotalSize, dataItems.size());
687 return (isFullItemFinished && isMatchItemFinished) ? -E_FINISHED : errCode;
688 }
689
OpenResultSet(const Key & keyPrefix,int & count)690 int SQLiteSingleVerStorageExecutor::OpenResultSet(const Key &keyPrefix, int &count)
691 {
692 sqlite3_stmt *countStatement = nullptr;
693 if (InitResultSet(keyPrefix, countStatement) != E_OK) {
694 LOGE("Initialize result set stat failed.");
695 return -E_INVALID_DB;
696 }
697
698 int errCode = StartTransaction(TransactType::DEFERRED);
699 if (errCode != E_OK) {
700 goto END;
701 }
702
703 // get count value
704 errCode = SQLiteUtils::StepWithRetry(countStatement, isMemDb_);
705 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
706 uint64_t readCount = static_cast<uint64_t>(sqlite3_column_int64(countStatement, 0));
707 if (readCount > INT32_MAX) {
708 LOGW("total count is beyond the max count");
709 count = 0;
710 errCode = -E_UNEXPECTED_DATA;
711 } else {
712 count = static_cast<int>(readCount);
713 errCode = E_OK;
714 }
715 LOGD("Entry count in this result set is %d", count);
716 } else {
717 errCode = -E_UNEXPECTED_DATA;
718 }
719
720 END:
721 SQLiteUtils::ResetStatement(countStatement, true, errCode);
722 if (errCode != E_OK) {
723 CloseResultSet();
724 }
725 return CheckCorruptedStatus(errCode);
726 }
727
OpenResultSet(QueryObject & queryObj,int & count)728 int SQLiteSingleVerStorageExecutor::OpenResultSet(QueryObject &queryObj, int &count)
729 {
730 sqlite3_stmt *countStatement = nullptr;
731 int errCode = InitResultSet(queryObj, countStatement);
732 if (errCode != E_OK) {
733 LOGE("Initialize result set stat failed.");
734 return errCode;
735 }
736
737 errCode = StartTransaction(TransactType::DEFERRED);
738 if (errCode != E_OK) {
739 goto END;
740 }
741
742 // get count value
743 errCode = SQLiteUtils::StepWithRetry(countStatement, isMemDb_);
744 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
745 uint64_t readCount = static_cast<uint64_t>(sqlite3_column_int64(countStatement, 0));
746 if (queryObj.HasLimit()) {
747 int limit = 0;
748 int offset = 0;
749 queryObj.GetLimitVal(limit, offset);
750 offset = (offset < 0) ? 0 : offset;
751 limit = (limit < 0) ? 0 : limit;
752 if (readCount <= static_cast<uint64_t>(offset)) {
753 readCount = 0;
754 } else {
755 readCount = std::min(readCount - offset, static_cast<uint64_t>(limit));
756 }
757 }
758
759 if (readCount > INT32_MAX) {
760 LOGW("total count is beyond the max count");
761 count = 0;
762 errCode = -E_UNEXPECTED_DATA;
763 } else {
764 count = static_cast<int>(readCount);
765 errCode = E_OK;
766 }
767 LOGD("Entry count in this result set is %d", count);
768 } else {
769 errCode = -E_UNEXPECTED_DATA;
770 }
771
772 END:
773 SQLiteUtils::ResetStatement(countStatement, true, errCode);
774 if (errCode != E_OK) {
775 CloseResultSet();
776 }
777 return CheckCorruptedStatus(errCode);
778 }
779
OpenResultSetForCacheRowIdMode(const Key & keyPrefix,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,int & count)780 int SQLiteSingleVerStorageExecutor::OpenResultSetForCacheRowIdMode(const Key &keyPrefix,
781 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, int &count)
782 {
783 if (dbHandle_ == nullptr) {
784 return -E_INVALID_DB;
785 }
786 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_ROWID_PREFIX_SQL, getResultRowIdStatement_);
787 if (errCode != E_OK) {
788 LOGE("[SqlSinExe][OpenResSetRowId][PrefixKey] Get rowId stmt fail, errCode=%d", errCode);
789 return CheckCorruptedStatus(errCode);
790 }
791 errCode = SQLiteUtils::BindPrefixKey(getResultRowIdStatement_, 1, keyPrefix); // first argument index is 1
792 if (errCode != E_OK) {
793 LOGE("[SqlSinExe][OpenResSetRowId][PrefixKey] Bind rowid stmt fail, errCode=%d", errCode);
794 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
795 return CheckCorruptedStatus(errCode);
796 }
797 errCode = OpenResultSetForCacheRowIdModeCommon(rowIdCache, cacheLimit, count);
798 if (errCode != E_OK) {
799 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
800 }
801 return errCode;
802 }
803
OpenResultSetForCacheRowIdMode(QueryObject & queryObj,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,int & count)804 int SQLiteSingleVerStorageExecutor::OpenResultSetForCacheRowIdMode(QueryObject &queryObj,
805 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, int &count)
806 {
807 if (dbHandle_ == nullptr) {
808 return -E_INVALID_DB;
809 }
810
811 int errCode = E_OK;
812 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
813 if (errCode != E_OK) {
814 return errCode;
815 }
816
817 if (!queryObj.IsValid()) {
818 LOGE("[SqlSinExe][OpenResSetRowId][Query] query object not Valid");
819 return -E_INVALID_QUERY_FORMAT;
820 }
821
822 errCode = helper.GetQuerySqlStatement(dbHandle_, true, getResultRowIdStatement_);
823 if (errCode != E_OK) {
824 LOGE("[SqlSinExe][OpenResSetRowId][Query] Get Stmt fail, errCode=%d", errCode);
825 // The GetQuerySqlStatement does not self rollback(BAD...), so we have to reset the stmt here.
826 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
827 return errCode;
828 }
829 errCode = OpenResultSetForCacheRowIdModeCommon(rowIdCache, cacheLimit, count);
830 if (errCode != E_OK) {
831 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
832 }
833 return errCode;
834 }
835
ReloadResultSet(const Key & keyPrefix)836 int SQLiteSingleVerStorageExecutor::ReloadResultSet(const Key &keyPrefix)
837 {
838 int errCode = ResetOrRegetStmt(dbHandle_, getResultRowIdStatement_, SELECT_SYNC_ROWID_PREFIX_SQL);
839 if (errCode != E_OK) {
840 return CheckCorruptedStatus(errCode);
841 }
842
843 // No need to reset getResultEntryStatement_. Because the binding of it will be cleared in each get operation
844 errCode = SQLiteUtils::BindPrefixKey(getResultRowIdStatement_, 1, keyPrefix); // first argument is key
845 if (errCode != E_OK) {
846 LOGE("Rebind result set rowid statement of keyPrefix error:%d", errCode);
847 return CheckCorruptedStatus(errCode);
848 }
849 return E_OK;
850 }
851
ReloadResultSet(QueryObject & queryObj)852 int SQLiteSingleVerStorageExecutor::ReloadResultSet(QueryObject &queryObj)
853 {
854 int errCode = E_OK;
855 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
856 if (errCode != E_OK) {
857 return errCode;
858 }
859
860 if (!queryObj.IsValid()) {
861 return -E_INVALID_QUERY_FORMAT;
862 }
863
864 std::string sql;
865 errCode = helper.GetQuerySql(sql, true); // only rowid sql
866 if (errCode != E_OK) {
867 return errCode;
868 }
869
870 errCode = ResetOrRegetStmt(dbHandle_, getResultRowIdStatement_, sql);
871 if (errCode != E_OK) {
872 return CheckCorruptedStatus(errCode);
873 }
874
875 // No need to reset getResultEntryStatement_. Because the binding of it will be cleared in each get operation
876 // GetQuerySqlStatement will not alter getResultRowIdStatement_ if it is not null
877 errCode = helper.GetQuerySqlStatement(dbHandle_, true, getResultRowIdStatement_);
878 if (errCode != E_OK) {
879 LOGE("Rebind result set rowid statement of query error:%d", errCode);
880 return CheckCorruptedStatus(errCode);
881 }
882 return E_OK;
883 }
884
ReloadResultSetForCacheRowIdMode(const Key & keyPrefix,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,uint32_t cacheStartPos)885 int SQLiteSingleVerStorageExecutor::ReloadResultSetForCacheRowIdMode(const Key &keyPrefix,
886 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, uint32_t cacheStartPos)
887 {
888 int errCode = ReloadResultSet(keyPrefix); // Reuse this function(A convenience)
889 if (errCode != E_OK) {
890 return errCode;
891 }
892 int count = 0; // Ignored
893 errCode = ResultSetLoadRowIdCache(rowIdCache, cacheLimit, cacheStartPos, count);
894 if (errCode != E_OK) {
895 LOGE("[SqlSinExe][ReloadResSet][KeyPrefix] Load fail, errCode=%d", errCode);
896 }
897 // We can just return, no need to reset the statement
898 return errCode;
899 }
900
ReloadResultSetForCacheRowIdMode(QueryObject & queryObj,std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,uint32_t cacheStartPos)901 int SQLiteSingleVerStorageExecutor::ReloadResultSetForCacheRowIdMode(QueryObject &queryObj,
902 std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, uint32_t cacheStartPos)
903 {
904 int errCode = ReloadResultSet(queryObj); // Reuse this function(A convenience)
905 if (errCode != E_OK) {
906 return errCode;
907 }
908 int count = 0; // Ignored
909 errCode = ResultSetLoadRowIdCache(rowIdCache, cacheLimit, cacheStartPos, count);
910 if (errCode != E_OK) {
911 LOGE("[SqlSinExe][ReloadResSet][Query] Load fail, errCode=%d", errCode);
912 }
913 // We can just return, no need to reset the statement
914 return errCode;
915 }
916
GetNextEntryFromResultSet(Key & key,Value & value,bool isCopy)917 int SQLiteSingleVerStorageExecutor::GetNextEntryFromResultSet(Key &key, Value &value, bool isCopy)
918 {
919 if (getResultRowIdStatement_ == nullptr || getResultEntryStatement_ == nullptr) {
920 return -E_RESULT_SET_STATUS_INVALID;
921 }
922
923 int errCode = SQLiteUtils::StepWithRetry(getResultRowIdStatement_, isMemDb_);
924 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
925 if (!isCopy) {
926 return E_OK;
927 }
928 int64_t rowId = sqlite3_column_int64(getResultRowIdStatement_, 0);
929 errCode = E_OK;
930 SQLiteUtils::ResetStatement(getResultEntryStatement_, false, errCode);
931 if (errCode != E_OK) {
932 LOGE("[SqlSinExe][GetNext] Reset result set entry statement fail, errCode=%d.", errCode);
933 return CheckCorruptedStatus(errCode);
934 }
935
936 SQLiteUtils::BindInt64ToStatement(getResultEntryStatement_, 1, rowId);
937 errCode = SQLiteUtils::StepWithRetry(getResultEntryStatement_, isMemDb_);
938 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
939 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 0, key);
940 if (errCode != E_OK) {
941 LOGE("[SqlSinExe][GetNext] Get key failed:%d", errCode);
942 return CheckCorruptedStatus(errCode);
943 }
944 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 1, value);
945 if (errCode != E_OK) {
946 LOGE("[SqlSinExe][GetNext] Get value failed:%d", errCode);
947 return CheckCorruptedStatus(errCode);
948 }
949 return E_OK;
950 } else {
951 return -E_UNEXPECTED_DATA;
952 }
953 }
954 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
955 return -E_FINISHED;
956 }
957
958 LOGE("SQLite step failed:%d", errCode);
959 return CheckCorruptedStatus(errCode);
960 }
961
GetEntryByRowId(int64_t rowId,Entry & entry)962 int SQLiteSingleVerStorageExecutor::GetEntryByRowId(int64_t rowId, Entry &entry)
963 {
964 if (getResultEntryStatement_ == nullptr) {
965 return -E_RESULT_SET_STATUS_INVALID;
966 }
967 int errCode = E_OK;
968 SQLiteUtils::ResetStatement(getResultEntryStatement_, false, errCode);
969 if (errCode != E_OK) {
970 LOGE("[SqlSinExe][GetEntryByRowid] Reset result set entry statement fail, errCode=%d.", errCode);
971 return CheckCorruptedStatus(errCode);
972 }
973 SQLiteUtils::BindInt64ToStatement(getResultEntryStatement_, 1, rowId);
974 errCode = SQLiteUtils::StepWithRetry(getResultEntryStatement_, isMemDb_);
975 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
976 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 0, entry.key);
977 if (errCode != E_OK) {
978 LOGE("[SqlSinExe][GetEntryByRowid] Get key failed, errCode=%d.", errCode);
979 return CheckCorruptedStatus(errCode);
980 }
981 errCode = SQLiteUtils::GetColumnBlobValue(getResultEntryStatement_, 1, entry.value);
982 if (errCode != E_OK) {
983 LOGE("[SqlSinExe][GetEntryByRowid] Get value failed, errCode=%d.", errCode);
984 return CheckCorruptedStatus(errCode);
985 }
986 return E_OK;
987 } else {
988 LOGE("[SqlSinExe][GetEntryByRowid] Step failed, errCode=%d.", errCode);
989 return -E_UNEXPECTED_DATA;
990 }
991 }
992
CloseResultSet()993 void SQLiteSingleVerStorageExecutor::CloseResultSet()
994 {
995 int errCode = E_OK;
996 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
997 if (errCode == -E_INVALID_PASSWD_OR_CORRUPTED_DB) {
998 SetCorruptedStatus();
999 }
1000 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
1001 if (errCode == -E_INVALID_PASSWD_OR_CORRUPTED_DB) {
1002 SetCorruptedStatus();
1003 }
1004 if (isTransactionOpen_) {
1005 SQLiteUtils::RollbackTransaction(dbHandle_);
1006 isTransactionOpen_ = false;
1007 }
1008 }
1009
StartTransaction(TransactType type)1010 int SQLiteSingleVerStorageExecutor::StartTransaction(TransactType type)
1011 {
1012 if (dbHandle_ == nullptr) {
1013 LOGE("Begin transaction failed, dbHandle is null.");
1014 return -E_INVALID_DB;
1015 }
1016 int errCode = SQLiteUtils::BeginTransaction(dbHandle_, type);
1017 if (errCode == E_OK) {
1018 isTransactionOpen_ = true;
1019 } else {
1020 LOGE("Begin transaction failed, errCode = %d", errCode);
1021 }
1022 return CheckCorruptedStatus(errCode);
1023 }
1024
Commit()1025 int SQLiteSingleVerStorageExecutor::Commit()
1026 {
1027 if (dbHandle_ == nullptr) {
1028 return -E_INVALID_DB;
1029 }
1030 int errCode = SQLiteUtils::CommitTransaction(dbHandle_);
1031 if (errCode != E_OK) {
1032 return CheckCorruptedStatus(errCode);
1033 }
1034 isTransactionOpen_ = false;
1035 return E_OK;
1036 }
1037
Rollback()1038 int SQLiteSingleVerStorageExecutor::Rollback()
1039 {
1040 if (dbHandle_ == nullptr) {
1041 return -E_INVALID_DB;
1042 }
1043 int errCode = SQLiteUtils::RollbackTransaction(dbHandle_);
1044 if (errCode != E_OK) {
1045 LOGE("sqlite single ver storage executor rollback fail! errCode = [%d]", errCode);
1046 return CheckCorruptedStatus(errCode);
1047 }
1048 isTransactionOpen_ = false;
1049 return E_OK;
1050 }
1051
CheckIfKeyExisted(const Key & key,bool isLocal,Value & value,TimeStamp & timeStamp) const1052 bool SQLiteSingleVerStorageExecutor::CheckIfKeyExisted(const Key &key, bool isLocal,
1053 Value &value, TimeStamp &timeStamp) const
1054 {
1055 // not local value, no need to get the value.
1056 if (!isLocal) {
1057 return false;
1058 }
1059
1060 int errCode = GetKvData(SingleVerDataType::LOCAL_TYPE, key, value, timeStamp);
1061 if (errCode != E_OK) {
1062 return false;
1063 }
1064 return true;
1065 }
1066
GetDeviceIdentifier(PragmaEntryDeviceIdentifier * identifier)1067 int SQLiteSingleVerStorageExecutor::GetDeviceIdentifier(PragmaEntryDeviceIdentifier *identifier)
1068 {
1069 if (identifier == nullptr) {
1070 return -E_INVALID_ARGS;
1071 }
1072
1073 if (dbHandle_ == nullptr) {
1074 return -E_INVALID_DB;
1075 }
1076
1077 sqlite3_stmt *statement = nullptr;
1078 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_ENTRY_DEVICE, statement);
1079 if (errCode != E_OK) {
1080 return errCode;
1081 }
1082
1083 int keyIndex = identifier->origDevice ? BIND_ORI_DEVICE_ID : BIND_PRE_DEVICE_ID;
1084 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_KV_KEY_INDEX, identifier->key, false);
1085 if (errCode != E_OK) {
1086 goto END;
1087 }
1088
1089 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1090 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1091 std::vector<uint8_t> deviceId;
1092 errCode = SQLiteUtils::GetColumnBlobValue(statement, keyIndex, deviceId);
1093 identifier->deviceIdentifier.assign(deviceId.begin(), deviceId.end());
1094 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1095 errCode = -E_NOT_FOUND;
1096 }
1097
1098 END:
1099 SQLiteUtils::ResetStatement(statement, true, errCode);
1100 return CheckCorruptedStatus(errCode);
1101 }
1102
PutIntoCommittedData(const DataItem & itemPut,const DataItem & itemGet,const DataOperStatus & status,const Key & hashKey,SingleVerNaturalStoreCommitNotifyData * committedData)1103 void SQLiteSingleVerStorageExecutor::PutIntoCommittedData(const DataItem &itemPut, const DataItem &itemGet,
1104 const DataOperStatus &status, const Key &hashKey, SingleVerNaturalStoreCommitNotifyData *committedData)
1105 {
1106 if (committedData == nullptr) {
1107 return;
1108 }
1109
1110 Entry entry;
1111 int errCode;
1112 if (!status.isDeleted) {
1113 entry.key = itemPut.key;
1114 entry.value = itemPut.value;
1115 DataType dataType = (status.preStatus == DataStatus::EXISTED) ? DataType::UPDATE : DataType::INSERT;
1116 errCode = committedData->InsertCommittedData(std::move(entry), dataType, true);
1117 } else {
1118 entry.key = itemGet.key;
1119 entry.value = itemGet.value;
1120 errCode = committedData->InsertCommittedData(std::move(entry), DataType::DELETE, true);
1121 }
1122
1123 if (errCode != E_OK) {
1124 LOGE("[SingleVerExe][PutCommitData]Insert failed:%d", errCode);
1125 }
1126 }
1127
PrepareForSavingData(const std::string & readSql,const std::string & insertSql,const std::string & updateSql,SaveRecordStatements & statements) const1128 int SQLiteSingleVerStorageExecutor::PrepareForSavingData(const std::string &readSql, const std::string &insertSql,
1129 const std::string &updateSql, SaveRecordStatements &statements) const
1130 {
1131 int errCode = SQLiteUtils::GetStatement(dbHandle_, readSql, statements.queryStatement);
1132 if (errCode != E_OK) {
1133 LOGE("Get query statement failed. errCode = [%d]", errCode);
1134 goto ERR;
1135 }
1136
1137 errCode = SQLiteUtils::GetStatement(dbHandle_, insertSql, statements.insertStatement);
1138 if (errCode != E_OK) {
1139 LOGE("Get insert statement failed. errCode = [%d]", errCode);
1140 goto ERR;
1141 }
1142
1143 errCode = SQLiteUtils::GetStatement(dbHandle_, updateSql, statements.updateStatement);
1144 if (errCode != E_OK) {
1145 LOGE("Get update statement failed. errCode = [%d]", errCode);
1146 goto ERR;
1147 }
1148 return E_OK;
1149 ERR:
1150 (void)statements.ResetStatement();
1151 return errCode;
1152 }
1153
PrepareForSavingData(SingleVerDataType type)1154 int SQLiteSingleVerStorageExecutor::PrepareForSavingData(SingleVerDataType type)
1155 {
1156 int errCode = -E_NOT_SUPPORT;
1157 if (type == SingleVerDataType::LOCAL_TYPE) {
1158 // currently, Local type has not been optimized, so pass updateSql parameter with INSERT_LOCAL_SQL
1159 errCode = PrepareForSavingData(SELECT_LOCAL_HASH_SQL, INSERT_LOCAL_SQL, INSERT_LOCAL_SQL, saveLocalStatements_);
1160 } else if (type == SingleVerDataType::SYNC_TYPE) {
1161 errCode = PrepareForSavingData(SELECT_SYNC_HASH_SQL, INSERT_SYNC_SQL, UPDATE_SYNC_SQL, saveSyncStatements_);
1162 }
1163 return CheckCorruptedStatus(errCode);
1164 }
1165
ResetForSavingData(SingleVerDataType type)1166 int SQLiteSingleVerStorageExecutor::ResetForSavingData(SingleVerDataType type)
1167 {
1168 int errCode = E_OK;
1169 if (type == SingleVerDataType::LOCAL_TYPE) {
1170 SQLiteUtils::ResetStatement(saveLocalStatements_.insertStatement, false, errCode);
1171 SQLiteUtils::ResetStatement(saveLocalStatements_.updateStatement, false, errCode);
1172 SQLiteUtils::ResetStatement(saveLocalStatements_.queryStatement, false, errCode);
1173 } else if (type == SingleVerDataType::SYNC_TYPE) {
1174 SQLiteUtils::ResetStatement(saveSyncStatements_.insertStatement, false, errCode);
1175 SQLiteUtils::ResetStatement(saveSyncStatements_.updateStatement, false, errCode);
1176 SQLiteUtils::ResetStatement(saveSyncStatements_.queryStatement, false, errCode);
1177 }
1178 return CheckCorruptedStatus(errCode);
1179 }
1180
GetOriginDevName(const DataItem & dataItem,const std::string & origDevGet)1181 std::string SQLiteSingleVerStorageExecutor::GetOriginDevName(const DataItem &dataItem,
1182 const std::string &origDevGet)
1183 {
1184 if (((dataItem.flag & DataItem::LOCAL_FLAG) != 0) && dataItem.origDev.empty()) {
1185 return origDevGet;
1186 }
1187 return dataItem.origDev;
1188 }
1189
SaveSyncDataToDatabase(const DataItem & dataItem,const Key & hashKey,const std::string & origDev,const std::string & deviceName,bool isUpdate)1190 int SQLiteSingleVerStorageExecutor::SaveSyncDataToDatabase(const DataItem &dataItem, const Key &hashKey,
1191 const std::string &origDev, const std::string &deviceName, bool isUpdate)
1192 {
1193 if ((dataItem.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) {
1194 LOGD("Find query data missing, erase local data.");
1195 return EraseSyncData(hashKey);
1196 }
1197 auto statement = saveSyncStatements_.GetDataSaveStatement(isUpdate);
1198 if (statement == nullptr) {
1199 return -E_INVALID_ARGS;
1200 }
1201
1202 std::string devName = DBCommon::TransferHashString(deviceName);
1203 int errCode = BindSavedSyncData(statement, dataItem, hashKey, {origDev, devName}, isUpdate);
1204 if (errCode != E_OK) {
1205 return errCode;
1206 }
1207
1208 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1209 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1210 errCode = E_OK;
1211 }
1212 return errCode;
1213 }
1214
JudgeSyncSaveType(DataItem & dataItem,const DataItem & itemGet,const std::string & devName,bool isHashKeyExisted,bool isPermitForceWrite)1215 DataOperStatus SQLiteSingleVerStorageExecutor::JudgeSyncSaveType(DataItem &dataItem,
1216 const DataItem &itemGet, const std::string &devName, bool isHashKeyExisted, bool isPermitForceWrite)
1217 {
1218 DataOperStatus status;
1219 status.isDeleted = ((dataItem.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
1220 (dataItem.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY);
1221 if (isHashKeyExisted) {
1222 if ((itemGet.flag & DataItem::DELETE_FLAG) != 0) {
1223 status.preStatus = DataStatus::DELETED;
1224 } else {
1225 status.preStatus = DataStatus::EXISTED;
1226 }
1227 std::string deviceName = DBCommon::TransferHashString(devName);
1228 if (itemGet.writeTimeStamp >= dataItem.writeTimeStamp) {
1229 // for multi user mode, no permit to forcewrite
1230 if ((!deviceName.empty()) && (itemGet.dev == deviceName) && isPermitForceWrite) {
1231 LOGI("Force overwrite the data:%llu vs %llu", itemGet.writeTimeStamp, dataItem.writeTimeStamp);
1232 status.isDefeated = false;
1233 dataItem.writeTimeStamp = itemGet.writeTimeStamp + 1;
1234 dataItem.timeStamp = itemGet.timeStamp;
1235 } else {
1236 status.isDefeated = true;
1237 }
1238 }
1239 }
1240 return status;
1241 }
1242
GetSyncDataItemExt(const DataItem & dataItem,DataItem & itemGet,const DataOperStatus & dataStatus) const1243 int SQLiteSingleVerStorageExecutor::GetSyncDataItemExt(const DataItem &dataItem, DataItem &itemGet,
1244 const DataOperStatus &dataStatus) const
1245 {
1246 if (dataStatus.preStatus != DataStatus::EXISTED) {
1247 return E_OK;
1248 }
1249 auto statement = isSyncMigrating_ ? migrateSyncStatements_.queryStatement : saveSyncStatements_.queryStatement;
1250 // only deleted item need origin value.
1251 int errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, itemGet.key);
1252 if (errCode != E_OK) {
1253 return errCode;
1254 }
1255
1256 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_VAL_INDEX, itemGet.value);
1257 if (errCode != E_OK) {
1258 LOGE("Get column value data failed:%d", errCode);
1259 }
1260
1261 return errCode;
1262 }
1263
ResetSaveSyncStatements(int errCode)1264 int SQLiteSingleVerStorageExecutor::ResetSaveSyncStatements(int errCode)
1265 {
1266 SQLiteUtils::ResetStatement(saveSyncStatements_.insertStatement, false, errCode);
1267 SQLiteUtils::ResetStatement(saveSyncStatements_.updateStatement, false, errCode);
1268 SQLiteUtils::ResetStatement(saveSyncStatements_.queryStatement, false, errCode);
1269 return CheckCorruptedStatus(errCode);
1270 }
1271
1272 namespace {
IsNeedIgnoredData(const DataItem & itemPut,const DataItem & itemGet,const DeviceInfo & devInfo,bool isHashKeyExisted,int policy)1273 inline bool IsNeedIgnoredData(const DataItem &itemPut, const DataItem &itemGet,
1274 const DeviceInfo &devInfo, bool isHashKeyExisted, int policy)
1275 {
1276 // deny the data synced from other dev which the origin dev is current or the existed value is current dev data.
1277 return (((itemGet.origDev.empty() && isHashKeyExisted) || itemPut.origDev.empty()) &&
1278 (!devInfo.isLocal && policy == DENY_OTHER_DEV_AMEND_CUR_DEV_DATA));
1279 }
1280 }
1281
PrepareForNotifyConflictAndObserver(DataItem & dataItem,const DeviceInfo & deviceInfo,NotifyConflictAndObserverData & notify,bool isPermitForceWrite)1282 int SQLiteSingleVerStorageExecutor::PrepareForNotifyConflictAndObserver(DataItem &dataItem,
1283 const DeviceInfo &deviceInfo, NotifyConflictAndObserverData ¬ify, bool isPermitForceWrite)
1284 {
1285 // Check sava data existed info
1286 int errCode = GetSyncDataItemPre(dataItem, notify.getData, notify.hashKey);
1287 if (errCode != E_OK && errCode != -E_NOT_FOUND) {
1288 LOGD("[SingleVerExe][PrepareForNotifyConflictAndObserver] failed:%d", errCode);
1289 if (isSyncMigrating_) {
1290 ResetForMigrateCacheData();
1291 return errCode;
1292 }
1293 return ResetSaveSyncStatements(errCode);
1294 }
1295
1296 bool isHashKeyExisted = (errCode != -E_NOT_FOUND);
1297 if (IsNeedIgnoredData(dataItem, notify.getData, deviceInfo, isHashKeyExisted, conflictResolvePolicy_)) {
1298 LOGD("[SingleVerExe] Ignore the sync data.");
1299 if (isSyncMigrating_) {
1300 ResetForMigrateCacheData();
1301 return -E_IGNORE_DATA;
1302 }
1303 return ResetSaveSyncStatements(-E_IGNORE_DATA);
1304 }
1305
1306 notify.dataStatus = JudgeSyncSaveType(dataItem, notify.getData, deviceInfo.deviceName, isHashKeyExisted,
1307 isPermitForceWrite);
1308 InitCommitNotifyDataKeyStatus(notify.committedData, notify.hashKey, notify.dataStatus);
1309
1310 // Nonexistent data, but deleted by local.
1311 if ((notify.dataStatus.preStatus == DataStatus::DELETED || notify.dataStatus.preStatus == DataStatus::NOEXISTED) &&
1312 (dataItem.flag & DataItem::DELETE_FLAG) != 0 &&
1313 (dataItem.flag & DataItem::LOCAL_FLAG) != 0) {
1314 // For delete item in cacheDB, which not in mainDB. Cannot notify, but this is not error.
1315 errCode = -E_NOT_FOUND;
1316 LOGD("Nonexistent data, but deleted by local");
1317 if (isSyncMigrating_) {
1318 ResetForMigrateCacheData();
1319 return errCode;
1320 }
1321 return ResetSaveSyncStatements(errCode);
1322 }
1323
1324 // get key and value from ori database
1325 errCode = GetSyncDataItemExt(dataItem, notify.getData, notify.dataStatus);
1326 if (errCode != E_OK) {
1327 LOGD("GetSyncDataItemExt failed:%d", errCode);
1328 if (isSyncMigrating_) {
1329 ResetForMigrateCacheData();
1330 return errCode;
1331 }
1332 return ResetSaveSyncStatements(errCode);
1333 }
1334
1335 return E_OK;
1336 }
1337
SaveSyncDataItem(DataItem & dataItem,const DeviceInfo & deviceInfo,TimeStamp & maxStamp,SingleVerNaturalStoreCommitNotifyData * committedData,bool isPermitForceWrite)1338 int SQLiteSingleVerStorageExecutor::SaveSyncDataItem(DataItem &dataItem, const DeviceInfo &deviceInfo,
1339 TimeStamp &maxStamp, SingleVerNaturalStoreCommitNotifyData *committedData, bool isPermitForceWrite)
1340 {
1341 NotifyConflictAndObserverData notify = {
1342 .committedData = committedData
1343 };
1344
1345 int errCode = PrepareForNotifyConflictAndObserver(dataItem, deviceInfo, notify, isPermitForceWrite);
1346 if (errCode != E_OK) {
1347 if (errCode == -E_IGNORE_DATA) {
1348 errCode = E_OK;
1349 }
1350 return errCode;
1351 }
1352
1353 PutConflictData(dataItem, notify.getData, deviceInfo, notify.dataStatus, committedData);
1354 if (notify.dataStatus.isDefeated) {
1355 LOGD("Data status is defeated:%d", errCode);
1356 return ResetSaveSyncStatements(errCode);
1357 }
1358
1359 bool isUpdate = (notify.dataStatus.preStatus != DataStatus::NOEXISTED);
1360 std::string origDev = GetOriginDevName(dataItem, notify.getData.origDev);
1361 errCode = SaveSyncDataToDatabase(dataItem, notify.hashKey, origDev, deviceInfo.deviceName, isUpdate);
1362 if (errCode == E_OK) {
1363 PutIntoCommittedData(dataItem, notify.getData, notify.dataStatus, notify.hashKey, committedData);
1364 maxStamp = std::max(dataItem.timeStamp, maxStamp);
1365 } else {
1366 LOGE("Save sync data to db failed:%d", errCode);
1367 }
1368 return ResetSaveSyncStatements(errCode);
1369 }
1370
GetAllMetaKeys(std::vector<Key> & keys) const1371 int SQLiteSingleVerStorageExecutor::GetAllMetaKeys(std::vector<Key> &keys) const
1372 {
1373 sqlite3_stmt *statement = nullptr;
1374 const std::string &sqlStr = (attachMetaMode_ ? SELECT_ATTACH_ALL_META_KEYS : SELECT_ALL_META_KEYS);
1375 int errCode = SQLiteUtils::GetStatement(dbHandle_, sqlStr, statement);
1376 if (errCode != E_OK) {
1377 LOGE("[SingleVerExe][GetAllKey] Get statement failed:%d", errCode);
1378 return errCode;
1379 }
1380
1381 errCode = GetAllKeys(statement, keys);
1382 SQLiteUtils::ResetStatement(statement, true, errCode);
1383 return errCode;
1384 }
1385
GetAllSyncedEntries(const std::string & deviceName,std::vector<Entry> & entries) const1386 int SQLiteSingleVerStorageExecutor::GetAllSyncedEntries(const std::string &deviceName,
1387 std::vector<Entry> &entries) const
1388 {
1389 sqlite3_stmt *statement = nullptr;
1390 std::string sql = (executorState_ == ExecutorState::CACHE_ATTACH_MAIN ?
1391 SELECT_ALL_SYNC_ENTRIES_BY_DEV_FROM_CACHEHANDLE : SELECT_ALL_SYNC_ENTRIES_BY_DEV);
1392 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
1393 if (errCode != E_OK) {
1394 LOGE("Get all entries statement failed:%d", errCode);
1395 return errCode;
1396 }
1397
1398 // When removing device data in cache mode, key is "remove", value is deviceID's hash string.
1399 // Therefore, no need to transfer hash string when migrating.
1400 std::string devName = isSyncMigrating_ ? deviceName : DBCommon::TransferHashString(deviceName);
1401 std::vector<uint8_t> devVect(devName.begin(), devName.end());
1402 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, devVect, true); // bind the 1st to device.
1403 if (errCode != E_OK) {
1404 LOGE("Failed to bind the synced device for all entries:%d", errCode);
1405 } else {
1406 errCode = GetAllEntries(statement, entries);
1407 }
1408
1409 SQLiteUtils::ResetStatement(statement, true, errCode);
1410 return errCode;
1411 }
1412
GetAllEntries(sqlite3_stmt * statement,std::vector<Entry> & entries) const1413 int SQLiteSingleVerStorageExecutor::GetAllEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const
1414 {
1415 if (statement == nullptr) {
1416 return -E_INVALID_DB;
1417 }
1418 int errCode;
1419 do {
1420 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1421 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1422 Entry entry;
1423 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, entry.key); // No.0 is the key
1424 if (errCode != E_OK) {
1425 break;
1426 }
1427 errCode = SQLiteUtils::GetColumnBlobValue(statement, 1, entry.value); // No.1 is the value
1428 if (errCode != E_OK) {
1429 break;
1430 }
1431
1432 entries.push_back(std::move(entry));
1433 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1434 errCode = E_OK;
1435 break;
1436 } else {
1437 LOGE("SQLite step for all entries failed:%d", errCode);
1438 break;
1439 }
1440 } while (true);
1441
1442 return errCode;
1443 }
1444
GetAllKeys(sqlite3_stmt * statement,std::vector<Key> & keys) const1445 int SQLiteSingleVerStorageExecutor::GetAllKeys(sqlite3_stmt *statement, std::vector<Key> &keys) const
1446 {
1447 if (statement == nullptr) {
1448 return -E_INVALID_DB;
1449 }
1450 int errCode;
1451 do {
1452 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1453 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1454 Key key;
1455 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, key);
1456 if (errCode != E_OK) {
1457 break;
1458 }
1459
1460 keys.push_back(std::move(key));
1461 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1462 errCode = E_OK;
1463 break;
1464 } else {
1465 LOGE("SQLite step for getting all keys failed:%d", errCode);
1466 break;
1467 }
1468 } while (true);
1469
1470 return errCode;
1471 }
1472
BindSavedSyncData(sqlite3_stmt * statement,const DataItem & dataItem,const Key & hashKey,const SyncDataDevices & devices,bool isUpdate)1473 int SQLiteSingleVerStorageExecutor::BindSavedSyncData(sqlite3_stmt *statement, const DataItem &dataItem,
1474 const Key &hashKey, const SyncDataDevices &devices, bool isUpdate)
1475 {
1476 const int hashKeyIndex = isUpdate ? BIND_SYNC_UPDATE_HASH_KEY_INDEX : BIND_SYNC_HASH_KEY_INDEX;
1477 int errCode = SQLiteUtils::BindBlobToStatement(statement, hashKeyIndex, hashKey, false);
1478 if (errCode != E_OK) {
1479 LOGE("Bind saved sync data hash key failed:%d", errCode);
1480 return errCode;
1481 }
1482
1483 // if delete flag is set, just use the hash key instead of the key
1484 if ((dataItem.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG) {
1485 errCode = SQLiteUtils::MapSQLiteErrno(sqlite3_bind_zeroblob(statement, BIND_SYNC_KEY_INDEX, -1));
1486 } else {
1487 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_KEY_INDEX, dataItem.key, false);
1488 }
1489
1490 if (errCode != E_OK) {
1491 LOGE("Bind saved sync data key failed:%d", errCode);
1492 return errCode;
1493 }
1494
1495 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_VAL_INDEX, dataItem.value, true);
1496 if (errCode != E_OK) {
1497 LOGE("Bind saved sync data value failed:%d", errCode);
1498 return errCode;
1499 }
1500
1501 errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_SYNC_STAMP_INDEX, dataItem.timeStamp);
1502 if (errCode != E_OK) {
1503 LOGE("Bind saved sync data stamp failed:%d", errCode);
1504 return errCode;
1505 }
1506
1507 const int writeTimeIndex = isUpdate ? BIND_SYNC_UPDATE_W_TIME_INDEX : BIND_SYNC_W_TIME_INDEX;
1508 errCode = SQLiteUtils::BindInt64ToStatement(statement, writeTimeIndex, dataItem.writeTimeStamp);
1509 LOGD("Write timestamp:%llu timestamp:%llu, %llu", dataItem.writeTimeStamp, dataItem.timeStamp, dataItem.flag);
1510 if (errCode != E_OK) {
1511 LOGE("Bind saved sync data write stamp failed:%d", errCode);
1512 return errCode;
1513 }
1514
1515 return BindDevForSavedSyncData(statement, dataItem, devices.origDev, devices.dev);
1516 }
1517
PutConflictData(const DataItem & itemPut,const DataItem & itemGet,const DeviceInfo & deviceInfo,const DataOperStatus & dataStatus,SingleVerNaturalStoreCommitNotifyData * commitData)1518 void SQLiteSingleVerStorageExecutor::PutConflictData(const DataItem &itemPut, const DataItem &itemGet,
1519 const DeviceInfo &deviceInfo, const DataOperStatus &dataStatus,
1520 SingleVerNaturalStoreCommitNotifyData *commitData)
1521 {
1522 if (commitData == nullptr) {
1523 return;
1524 }
1525
1526 bool conflictNotifyMatch = commitData->IsConflictedNotifyMatched(itemPut, itemGet);
1527 if (!conflictNotifyMatch) {
1528 return;
1529 }
1530
1531 if (dataStatus.preStatus == DataStatus::NOEXISTED ||
1532 ((dataStatus.preStatus == DataStatus::DELETED) && dataStatus.isDeleted)) {
1533 return;
1534 }
1535
1536 Key origKey;
1537 if ((itemPut.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
1538 (itemPut.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) {
1539 origKey = itemGet.key;
1540 } else {
1541 origKey = itemPut.key;
1542 }
1543
1544 // insert db original entry
1545 std::vector<uint8_t> getDevVect(itemGet.dev.begin(), itemGet.dev.end());
1546 DataItemInfo orgItemInfo = {itemGet, true, getDevVect};
1547 orgItemInfo.dataItem.key = origKey;
1548 commitData->InsertConflictedItem(orgItemInfo, true);
1549
1550 // insert conflict entry
1551 std::string putDeviceName = DBCommon::TransferHashString(deviceInfo.deviceName);
1552 std::vector<uint8_t> putDevVect(putDeviceName.begin(), putDeviceName.end());
1553
1554 DataItemInfo newItemInfo = {itemPut, deviceInfo.isLocal, putDevVect};
1555 newItemInfo.dataItem.key = origKey;
1556 commitData->InsertConflictedItem(newItemInfo, false);
1557 }
1558
Reset()1559 int SQLiteSingleVerStorageExecutor::Reset()
1560 {
1561 if (isTransactionOpen_) {
1562 Rollback();
1563 }
1564
1565 int errCode = ResetForSavingData(SingleVerDataType::SYNC_TYPE);
1566 if (errCode != E_OK) {
1567 LOGE("Finalize the sync resources for saving sync data failed: %d", errCode);
1568 }
1569
1570 errCode = ResetForSavingData(SingleVerDataType::LOCAL_TYPE);
1571 if (errCode != E_OK) {
1572 LOGE("Finalize the local resources for saving sync data failed: %d", errCode);
1573 }
1574 return SQLiteStorageExecutor::Reset();
1575 }
1576
GetSyncDataItemPre(const DataItem & itemPut,DataItem & itemGet,Key & hashKey) const1577 int SQLiteSingleVerStorageExecutor::GetSyncDataItemPre(const DataItem &itemPut, DataItem &itemGet,
1578 Key &hashKey) const
1579 {
1580 if (isSyncMigrating_) {
1581 hashKey = itemPut.hashKey;
1582 } else if ((itemPut.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
1583 ((itemPut.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY)) {
1584 hashKey = itemPut.key;
1585 } else {
1586 int errCode = DBCommon::CalcValueHash(itemPut.key, hashKey);
1587 if (errCode != E_OK) {
1588 return errCode;
1589 }
1590 }
1591
1592 return GetSyncDataPreByHashKey(hashKey, itemGet);
1593 }
1594
GetSyncDataPreByHashKey(const Key & hashKey,DataItem & itemGet) const1595 int SQLiteSingleVerStorageExecutor::GetSyncDataPreByHashKey(const Key &hashKey, DataItem &itemGet) const
1596 {
1597 auto statement = isSyncMigrating_ ? migrateSyncStatements_.queryStatement : saveSyncStatements_.queryStatement;
1598 int errCode = SQLiteUtils::BindBlobToStatement(statement, 1, hashKey, false); // 1st arg.
1599 if (errCode != E_OK) {
1600 return errCode;
1601 }
1602
1603 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1604 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // no find the key
1605 errCode = -E_NOT_FOUND;
1606 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1607 itemGet.timeStamp = static_cast<TimeStamp>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
1608 itemGet.writeTimeStamp = static_cast<TimeStamp>(sqlite3_column_int64(statement, SYNC_RES_W_TIME_INDEX));
1609 itemGet.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
1610 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, itemGet.key);
1611 if (errCode != E_OK) {
1612 return errCode;
1613 }
1614 std::vector<uint8_t> devVect;
1615 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_DEVICE_INDEX, devVect);
1616 if (errCode != E_OK) {
1617 return errCode;
1618 }
1619
1620 std::vector<uint8_t> origDevVect;
1621 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_ORI_DEV_INDEX, origDevVect);
1622 if (errCode != E_OK) {
1623 return errCode;
1624 }
1625 itemGet.dev.assign(devVect.begin(), devVect.end());
1626 itemGet.origDev.assign(origDevVect.begin(), origDevVect.end());
1627 }
1628 return errCode;
1629 }
1630
DeleteLocalDataInner(SingleVerNaturalStoreCommitNotifyData * committedData,const Key & key,const Value & value)1631 int SQLiteSingleVerStorageExecutor::DeleteLocalDataInner(SingleVerNaturalStoreCommitNotifyData *committedData,
1632 const Key &key, const Value &value)
1633 {
1634 if (committedData != nullptr) {
1635 Key hashKey;
1636 int innerErrCode = DBCommon::CalcValueHash(key, hashKey);
1637 if (innerErrCode != E_OK) {
1638 return innerErrCode;
1639 }
1640 committedData->InitKeyPropRecord(hashKey, ExistStatus::EXIST);
1641 }
1642
1643 std::string sql = DELETE_LOCAL_SQL;
1644 if (executorState_ == ExecutorState::CACHE_ATTACH_MAIN) {
1645 sql = DELETE_LOCAL_SQL_FROM_CACHEHANDLE;
1646 }
1647 sqlite3_stmt *statement = nullptr;
1648 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
1649 if (errCode != E_OK) {
1650 goto ERROR;
1651 }
1652
1653 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, key, false);
1654 if (errCode != E_OK) {
1655 LOGE("Bind the key error(%d) when delete kv data.", errCode);
1656 goto ERROR;
1657 }
1658
1659 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1660 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1661 if (sqlite3_changes(dbHandle_) > 0) {
1662 if (committedData != nullptr) {
1663 Entry entry = {key, value};
1664 committedData->InsertCommittedData(std::move(entry), DataType::DELETE, true);
1665 } else {
1666 LOGE("DeleteLocalKvData failed to do commit notify because of OOM.");
1667 }
1668 errCode = E_OK;
1669 }
1670 }
1671
1672 ERROR:
1673 SQLiteUtils::ResetStatement(statement, true, errCode);
1674 return CheckCorruptedStatus(errCode);
1675 }
1676
DeleteLocalKvData(const Key & key,SingleVerNaturalStoreCommitNotifyData * committedData,Value & value,TimeStamp & timeStamp)1677 int SQLiteSingleVerStorageExecutor::DeleteLocalKvData(const Key &key,
1678 SingleVerNaturalStoreCommitNotifyData *committedData, Value &value, TimeStamp &timeStamp)
1679 {
1680 int errCode = GetKvData(SingleVerDataType::LOCAL_TYPE, key, value, timeStamp);
1681 if (errCode != E_OK) {
1682 return CheckCorruptedStatus(errCode);
1683 }
1684
1685 return DeleteLocalDataInner(committedData, key, value);
1686 }
1687
EraseSyncData(const Key & hashKey)1688 int SQLiteSingleVerStorageExecutor::EraseSyncData(const Key &hashKey)
1689 {
1690 sqlite3_stmt *stmt = nullptr;
1691 std::string sql = (executorState_ == ExecutorState::CACHE_ATTACH_MAIN) ?
1692 DELETE_SYNC_DATA_WITH_HASHKEY_FROM_CACHEHANDLE : DELETE_SYNC_DATA_WITH_HASHKEY;
1693 int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, stmt);
1694 if (errCode != E_OK) {
1695 LOGE("get erase statement failed:%d", errCode);
1696 return errCode;
1697 }
1698
1699 errCode = SQLiteUtils::BindBlobToStatement(stmt, 1, hashKey, false);
1700 if (errCode != E_OK) {
1701 LOGE("bind hashKey failed:%d", errCode);
1702 goto END;
1703 }
1704
1705 errCode = SQLiteUtils::StepWithRetry(stmt, false);
1706 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1707 errCode = E_OK;
1708 } else {
1709 LOGE("erase data failed:%d", errCode);
1710 }
1711 END:
1712 SQLiteUtils::ResetStatement(stmt, true, errCode);
1713 return CheckCorruptedStatus(errCode);
1714 }
1715
RemoveDeviceData(const std::string & deviceName)1716 int SQLiteSingleVerStorageExecutor::RemoveDeviceData(const std::string &deviceName)
1717 {
1718 // Transfer the device name.
1719 std::string devName = DBCommon::TransferHashString(deviceName);
1720 sqlite3_stmt *statement = nullptr;
1721 std::vector<uint8_t> devVect(devName.begin(), devName.end());
1722
1723 int errCode = SQLiteUtils::GetStatement(dbHandle_, REMOVE_DEV_DATA_SQL, statement);
1724 if (errCode != E_OK) {
1725 goto ERROR;
1726 }
1727
1728 errCode = SQLiteUtils::BindBlobToStatement(statement, 1, devVect, true); // only one arg.
1729 if (errCode != E_OK) {
1730 LOGE("Failed to bind the removed device:%d", errCode);
1731 goto ERROR;
1732 }
1733
1734 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1735 if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1736 LOGE("Failed to execute rm the device synced data:%d", errCode);
1737 } else {
1738 errCode = E_OK;
1739 }
1740
1741 ERROR:
1742 SQLiteUtils::ResetStatement(statement, true, errCode);
1743 return CheckCorruptedStatus(errCode);
1744 }
1745
StepForResultEntries(sqlite3_stmt * statement,std::vector<Entry> & entries) const1746 int SQLiteSingleVerStorageExecutor::StepForResultEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const
1747 {
1748 entries.clear();
1749 entries.shrink_to_fit();
1750 Entry entry;
1751 int errCode = E_OK;
1752 do {
1753 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
1754 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
1755 errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, entry.key);
1756 if (errCode != E_OK) {
1757 return errCode;
1758 }
1759
1760 errCode = SQLiteUtils::GetColumnBlobValue(statement, 1, entry.value);
1761 if (errCode != E_OK) {
1762 return errCode;
1763 }
1764
1765 entries.push_back(std::move(entry));
1766 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
1767 errCode = E_OK;
1768 break;
1769 } else {
1770 LOGE("SQLite step failed:%d", errCode);
1771 return errCode;
1772 }
1773 } while (true);
1774
1775 // if select no result, return the -E_NOT_FOUND.
1776 if (entries.empty()) {
1777 errCode = -E_NOT_FOUND;
1778 }
1779
1780 return errCode;
1781 }
1782
BindDevForSavedSyncData(sqlite3_stmt * statement,const DataItem & dataItem,const std::string & origDev,const std::string & deviceName)1783 int SQLiteSingleVerStorageExecutor::BindDevForSavedSyncData(sqlite3_stmt *statement, const DataItem &dataItem,
1784 const std::string &origDev, const std::string &deviceName)
1785 {
1786 int errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_SYNC_FLAG_INDEX,
1787 static_cast<int64_t>(dataItem.flag));
1788 if (errCode != E_OK) {
1789 LOGE("Bind saved sync data flag failed:%d", errCode);
1790 return errCode;
1791 }
1792
1793 std::vector<uint8_t> devVect(deviceName.begin(), deviceName.end());
1794 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_DEV_INDEX, devVect, true);
1795 if (errCode != E_OK) {
1796 LOGE("Bind dev for sync data failed:%d", errCode);
1797 return errCode;
1798 }
1799
1800 std::vector<uint8_t> origDevVect(origDev.begin(), origDev.end());
1801 errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_SYNC_ORI_DEV_INDEX, origDevVect, true);
1802 if (errCode != E_OK) {
1803 LOGE("Bind orig dev for sync data failed:%d", errCode);
1804 }
1805
1806 return errCode;
1807 }
1808
GetDataItemSerialSize(const DataItem & item,size_t appendLen)1809 size_t SQLiteSingleVerStorageExecutor::GetDataItemSerialSize(const DataItem &item, size_t appendLen)
1810 {
1811 // timestamp and local flag: 3 * uint64_t, version(uint32_t), key, value, origin dev and the padding size.
1812 // the size would not be very large.
1813 static const size_t maxOrigDevLength = 40;
1814 size_t devLength = std::max(maxOrigDevLength, item.origDev.size());
1815 size_t dataSize = (Parcel::GetUInt64Len() * 3 + Parcel::GetUInt32Len() + Parcel::GetVectorCharLen(item.key) +
1816 Parcel::GetVectorCharLen(item.value) + devLength + appendLen);
1817
1818 return dataSize;
1819 }
1820
InitResultSet(const Key & keyPrefix,sqlite3_stmt * & countStmt)1821 int SQLiteSingleVerStorageExecutor::InitResultSet(const Key &keyPrefix, sqlite3_stmt *&countStmt)
1822 {
1823 if (dbHandle_ == nullptr) {
1824 return -E_INVALID_DB;
1825 }
1826 // bind statement for count
1827 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_COUNT_SYNC_PREFIX_SQL, countStmt);
1828 if (errCode != E_OK) {
1829 LOGE("Get count statement for resultset error:%d", errCode);
1830 return errCode;
1831 }
1832
1833 errCode = SQLiteUtils::BindPrefixKey(countStmt, 1, keyPrefix); // first argument is key
1834 if (errCode != E_OK) {
1835 LOGE("Bind count key error:%d", errCode);
1836 goto ERROR;
1837 }
1838 // bind statement for result set
1839 errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_ROWID_PREFIX_SQL, getResultRowIdStatement_);
1840 if (errCode != E_OK) {
1841 LOGE("Get result set rowid statement error:%d", errCode);
1842 goto ERROR;
1843 }
1844
1845 errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_DATA_BY_ROWID_SQL, getResultEntryStatement_);
1846 if (errCode != E_OK) {
1847 LOGE("Get result set entry statement error:%d", errCode);
1848 goto ERROR;
1849 }
1850
1851 errCode = SQLiteUtils::BindPrefixKey(getResultRowIdStatement_, 1, keyPrefix); // first argument is key
1852 if (errCode != E_OK) {
1853 LOGE("Bind result set rowid statement error:%d", errCode);
1854 goto ERROR;
1855 }
1856 return E_OK;
1857
1858 ERROR:
1859 SQLiteUtils::ResetStatement(countStmt, true, errCode);
1860 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
1861 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
1862 return CheckCorruptedStatus(errCode);
1863 }
1864
InitResultSetCount(QueryObject & queryObj,sqlite3_stmt * & countStmt)1865 int SQLiteSingleVerStorageExecutor::InitResultSetCount(QueryObject &queryObj, sqlite3_stmt *&countStmt)
1866 {
1867 if (dbHandle_ == nullptr) {
1868 return -E_INVALID_DB;
1869 }
1870
1871 int errCode = E_OK;
1872 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
1873 if (errCode != E_OK) {
1874 return errCode;
1875 }
1876
1877 errCode = helper.GetCountSqlStatement(dbHandle_, countStmt);
1878 if (errCode != E_OK) {
1879 LOGE("Get count bind statement error:%d", errCode);
1880 SQLiteUtils::ResetStatement(countStmt, true, errCode);
1881 }
1882 return errCode;
1883 }
1884
InitResultSetContent(QueryObject & queryObj)1885 int SQLiteSingleVerStorageExecutor::InitResultSetContent(QueryObject &queryObj)
1886 {
1887 int errCode = E_OK;
1888 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
1889 if (errCode != E_OK) {
1890 return errCode;
1891 }
1892
1893 // bind statement for result set
1894 errCode = helper.GetQuerySqlStatement(dbHandle_, true, getResultRowIdStatement_);
1895 if (errCode != E_OK) {
1896 LOGE("[SqlSinExe][InitResSetContent] Bind result set rowid statement of query error:%d", errCode);
1897 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
1898 return errCode;
1899 }
1900 errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_DATA_BY_ROWID_SQL, getResultEntryStatement_);
1901 if (errCode != E_OK) {
1902 LOGE("[SqlSinExe][InitResSetContent] Get result set entry statement of query error:%d", errCode);
1903 return CheckCorruptedStatus(errCode);
1904 }
1905 return errCode;
1906 }
1907
InitResultSet(QueryObject & queryObj,sqlite3_stmt * & countStmt)1908 int SQLiteSingleVerStorageExecutor::InitResultSet(QueryObject &queryObj, sqlite3_stmt *&countStmt)
1909 {
1910 if (dbHandle_ == nullptr) {
1911 return -E_INVALID_DB;
1912 }
1913
1914 int errCode = E_OK;
1915 SqliteQueryHelper helper = queryObj.GetQueryHelper(errCode);
1916 if (errCode != E_OK) {
1917 return errCode;
1918 }
1919
1920 if (!queryObj.IsValid()) {
1921 return -E_INVALID_QUERY_FORMAT;
1922 }
1923
1924 errCode = InitResultSetCount(queryObj, countStmt);
1925 if (errCode != E_OK) {
1926 return CheckCorruptedStatus(errCode);
1927 }
1928
1929 errCode = InitResultSetContent(queryObj);
1930 if (errCode != E_OK) {
1931 SQLiteUtils::ResetStatement(countStmt, true, errCode);
1932 }
1933 return CheckCorruptedStatus(errCode);
1934 }
1935
UpdateLocalDataTimestamp(TimeStamp timestamp)1936 int SQLiteSingleVerStorageExecutor::UpdateLocalDataTimestamp(TimeStamp timestamp)
1937 {
1938 const std::string updateSql = "UPDATE local_data SET timestamp=";
1939 std::string sql = updateSql + std::to_string(timestamp) + " WHERE timestamp=0;";
1940 int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
1941 return CheckCorruptedStatus(errCode);
1942 }
1943
SetAttachMetaMode(bool attachMetaMode)1944 void SQLiteSingleVerStorageExecutor::SetAttachMetaMode(bool attachMetaMode)
1945 {
1946 attachMetaMode_ = attachMetaMode;
1947 }
1948
GetOneRawDataItem(sqlite3_stmt * statement,DataItem & dataItem,uint64_t & verInCurCacheDb,bool isCacheDb) const1949 int SQLiteSingleVerStorageExecutor::GetOneRawDataItem(sqlite3_stmt *statement, DataItem &dataItem,
1950 uint64_t &verInCurCacheDb, bool isCacheDb) const
1951 {
1952 int errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_KEY_INDEX, dataItem.key);
1953 if (errCode != E_OK) {
1954 return errCode;
1955 }
1956
1957 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_VAL_INDEX, dataItem.value);
1958 if (errCode != E_OK) {
1959 return errCode;
1960 }
1961
1962 dataItem.timeStamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
1963 dataItem.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
1964
1965 std::vector<uint8_t> devVect;
1966 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_DEVICE_INDEX, devVect);
1967 if (errCode != E_OK) {
1968 return errCode;
1969 }
1970 dataItem.dev = std::string(devVect.begin(), devVect.end());
1971
1972 devVect.clear();
1973 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_ORI_DEV_INDEX, devVect);
1974 if (errCode != E_OK) {
1975 return errCode;
1976 }
1977 dataItem.origDev = std::string(devVect.begin(), devVect.end());
1978
1979 errCode = SQLiteUtils::GetColumnBlobValue(statement, SYNC_RES_HASH_KEY_INDEX, dataItem.hashKey);
1980 if (errCode != E_OK) {
1981 return errCode;
1982 }
1983 dataItem.writeTimeStamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_W_TIME_INDEX));
1984 if (errCode != E_OK) {
1985 return errCode;
1986 }
1987 if (isCacheDb) {
1988 verInCurCacheDb = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_VERSION_INDEX));
1989 }
1990 return E_OK;
1991 }
1992
GetAllDataItems(sqlite3_stmt * statement,std::vector<DataItem> & dataItems,uint64_t & verInCurCacheDb,bool isCacheDb) const1993 int SQLiteSingleVerStorageExecutor::GetAllDataItems(sqlite3_stmt *statement, std::vector<DataItem> &dataItems,
1994 uint64_t &verInCurCacheDb, bool isCacheDb) const
1995 {
1996 dataItems.clear();
1997 dataItems.shrink_to_fit();
1998 DataItem dataItem;
1999 int errCode;
2000 do {
2001 errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
2002 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
2003 errCode = GetOneRawDataItem(statement, dataItem, verInCurCacheDb, isCacheDb);
2004 if (errCode != E_OK) {
2005 return errCode;
2006 }
2007 dataItems.push_back(std::move(dataItem));
2008 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
2009 errCode = E_OK;
2010 break;
2011 } else {
2012 LOGE("SQLite step failed:%d", errCode);
2013 break;
2014 }
2015 } while (true);
2016
2017 return CheckCorruptedStatus(errCode);
2018 }
2019
OpenResultSetForCacheRowIdModeCommon(std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,int & count)2020 int SQLiteSingleVerStorageExecutor::OpenResultSetForCacheRowIdModeCommon(std::vector<int64_t> &rowIdCache,
2021 uint32_t cacheLimit, int &count)
2022 {
2023 int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SYNC_DATA_BY_ROWID_SQL, getResultEntryStatement_);
2024 if (errCode != E_OK) {
2025 LOGE("[SqlSinExe][OpenResSetRowId][Common] Get entry stmt fail, errCode=%d", errCode);
2026 return CheckCorruptedStatus(errCode);
2027 }
2028 errCode = StartTransaction(TransactType::DEFERRED);
2029 if (errCode != E_OK) {
2030 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
2031 return CheckCorruptedStatus(errCode);
2032 }
2033 // Now Ready To Execute
2034 errCode = ResultSetLoadRowIdCache(rowIdCache, cacheLimit, 0, count);
2035 if (errCode != E_OK) {
2036 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
2037 Rollback();
2038 return CheckCorruptedStatus(errCode);
2039 }
2040 // Consider finalize getResultRowIdStatement_ here if count equal to size of rowIdCache.
2041 return E_OK;
2042 }
2043
ResultSetLoadRowIdCache(std::vector<int64_t> & rowIdCache,uint32_t cacheLimit,uint32_t cacheStartPos,int & count)2044 int SQLiteSingleVerStorageExecutor::ResultSetLoadRowIdCache(std::vector<int64_t> &rowIdCache, uint32_t cacheLimit,
2045 uint32_t cacheStartPos, int &count)
2046 {
2047 rowIdCache.clear();
2048 count = 0;
2049 while (true) {
2050 int errCode = SQLiteUtils::StepWithRetry(getResultRowIdStatement_, isMemDb_);
2051 if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
2052 if (count >= static_cast<int>(cacheStartPos) && rowIdCache.size() < cacheLimit) {
2053 // If we can start cache, and, if we can still cache
2054 int64_t rowid = sqlite3_column_int64(getResultRowIdStatement_, 0);
2055 rowIdCache.push_back(rowid);
2056 }
2057 // Always increase the count
2058 count++;
2059 } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
2060 break;
2061 } else {
2062 LOGE("[SqlSinExe][ResSetLoadCache] Step fail, errCode=%d", errCode);
2063 rowIdCache.clear();
2064 count = 0;
2065 return CheckCorruptedStatus(errCode);
2066 }
2067 }
2068 return E_OK;
2069 }
2070
ResetStatement()2071 int SQLiteSingleVerStorageExecutor::SaveRecordStatements::ResetStatement()
2072 {
2073 int errCode = E_OK;
2074 SQLiteUtils::ResetStatement(insertStatement, true, errCode);
2075 if (errCode != E_OK) {
2076 LOGE("Finalize insert statements failed, error: %d", errCode);
2077 }
2078
2079 SQLiteUtils::ResetStatement(updateStatement, true, errCode);
2080 if (errCode != E_OK) {
2081 LOGE("Finalize update statements failed, error: %d", errCode);
2082 }
2083
2084 SQLiteUtils::ResetStatement(queryStatement, true, errCode);
2085 if (errCode != E_OK) {
2086 LOGE("Finalize query statement failed, error: %d", errCode);
2087 }
2088 return errCode;
2089 }
2090
FinalizeAllStatements()2091 void SQLiteSingleVerStorageExecutor::FinalizeAllStatements()
2092 {
2093 int errCode = saveLocalStatements_.ResetStatement();
2094 if (errCode != E_OK) {
2095 LOGE("Finalize saveLocal statements failed, error: %d", errCode);
2096 }
2097
2098 errCode = saveSyncStatements_.ResetStatement();
2099 if (errCode != E_OK) {
2100 LOGE("Finalize saveSync statement failed, error: %d", errCode);
2101 }
2102
2103 SQLiteUtils::ResetStatement(getResultRowIdStatement_, true, errCode);
2104 if (errCode != E_OK) {
2105 LOGE("Finalize getResultRowIdStatement_ failed, error: %d", errCode);
2106 }
2107
2108 SQLiteUtils::ResetStatement(getResultEntryStatement_, true, errCode);
2109 if (errCode != E_OK) {
2110 LOGE("Finalize getResultEntryStatement_ failed, error: %d", errCode);
2111 }
2112
2113 errCode = migrateSyncStatements_.ResetStatement();
2114 if (errCode != E_OK) {
2115 LOGE("Finalize migrateSync statements failed, error: %d", errCode);
2116 }
2117
2118 ReleaseContinueStatement();
2119 }
2120
SetConflictResolvePolicy(int policy)2121 void SQLiteSingleVerStorageExecutor::SetConflictResolvePolicy(int policy)
2122 {
2123 if (policy == DENY_OTHER_DEV_AMEND_CUR_DEV_DATA || policy == DEFAULT_LAST_WIN) {
2124 conflictResolvePolicy_ = policy;
2125 }
2126 }
2127
CheckIntegrity() const2128 int SQLiteSingleVerStorageExecutor::CheckIntegrity() const
2129 {
2130 if (dbHandle_ == nullptr) {
2131 return -E_INVALID_DB;
2132 }
2133
2134 return SQLiteUtils::CheckIntegrity(dbHandle_, CHECK_DB_INTEGRITY_SQL);
2135 }
2136
ForceCheckPoint() const2137 int SQLiteSingleVerStorageExecutor::ForceCheckPoint() const
2138 {
2139 if (dbHandle_ == nullptr) {
2140 return -E_INVALID_DB;
2141 }
2142 SQLiteUtils::ExecuteCheckPoint(dbHandle_);
2143 return E_OK;
2144 }
2145
GetLogFileSize() const2146 uint64_t SQLiteSingleVerStorageExecutor::GetLogFileSize() const
2147 {
2148 if (isMemDb_) {
2149 return 0;
2150 }
2151
2152 const char *fileName = sqlite3_db_filename(dbHandle_, "main");
2153 if (fileName == nullptr) {
2154 return 0;
2155 }
2156 std::string walName = std::string(fileName) + "-wal";
2157 uint64_t fileSize = 0;
2158 int result = OS::CalFileSize(std::string(walName), fileSize);
2159 if (result != E_OK) {
2160 return 0;
2161 }
2162 return fileSize;
2163 }
2164 } // namespace DistributedDB
2165