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