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 #ifndef SQLITE_SINGLE_VER_STORAGE_EXECUTOR_H
17 #define SQLITE_SINGLE_VER_STORAGE_EXECUTOR_H
18 
19 #include "macro_utils.h"
20 #include "db_types.h"
21 #include "query_object.h"
22 #include "sqlite_utils.h"
23 #include "sqlite_storage_executor.h"
24 #include "single_ver_natural_store_commit_notify_data.h"
25 
26 namespace DistributedDB {
27 class SQLiteSingleVerStorageExecutor : public SQLiteStorageExecutor {
28 public:
29     SQLiteSingleVerStorageExecutor(sqlite3 *dbHandle, bool writable, bool isMemDb);
30     SQLiteSingleVerStorageExecutor(sqlite3 *dbHandle, bool writable, bool isMemDb, ExecutorState executorState);
31     ~SQLiteSingleVerStorageExecutor() override;
32 
33     // Delete the copy and assign constructors
34     DISABLE_COPY_ASSIGN_MOVE(SQLiteSingleVerStorageExecutor);
35 
36     // Get the Kv data according the type(sync, meta, local data).
37     virtual int GetKvData(SingleVerDataType type, const Key &key, Value &value, Timestamp &timestamp) const;
38 
39     // Get the sync data record by hash key.
40     int GetKvDataByHashKey(const Key &hashKey, SingleVerRecord &result) const;
41 
42     // Put the Kv data according the type(meta and the local data).
43     virtual int PutKvData(SingleVerDataType type, const Key &key, const Value &value,
44         Timestamp timestamp, SingleVerNaturalStoreCommitNotifyData *committedData);
45 
46     virtual int GetEntries(bool isGetValue, SingleVerDataType type, const Key &keyPrefix,
47         std::vector<Entry> &entries) const;
48 
49     int GetEntries(QueryObject &queryObj, std::vector<Entry> &entries) const;
50 
51     int GetCount(QueryObject &queryObj, int &count) const;
52 
53     // Get all the meta keys.
54     int GetAllMetaKeys(std::vector<Key> &keys) const;
55 
56     int GetAllSyncedEntries(const std::string &hashDev, std::vector<Entry> &entries) const;
57 
58     int SaveSyncDataItem(DataItem &dataItem, const DeviceInfo &deviceInfo,
59         Timestamp &maxStamp, SingleVerNaturalStoreCommitNotifyData *committedData, bool isPermitForceWrite = true);
60 
61     virtual int DeleteLocalKvData(const Key &key, SingleVerNaturalStoreCommitNotifyData *committedData, Value &value,
62         Timestamp &timestamp);
63 
64     // delete a row data by hashKey, with no tombstone left.
65     int EraseSyncData(const Key &hashKey);
66 
67     int RemoveDeviceData(const std::string &deviceName);
68 
69     int RemoveDeviceData(const std::string &deviceName, ClearMode mode);
70 
71     int RemoveDeviceData(const std::string &deviceName, const std::string &user, ClearMode mode);
72 
73     int RemoveDeviceDataInCacheMode(const std::string &hashDev, bool isNeedNotify, uint64_t recordVersion) const;
74 
75     void InitCurrentMaxStamp(Timestamp &maxStamp);
76 
77     void ReleaseContinueStatement();
78 
79     int GetSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength, Timestamp begin,
80         Timestamp end, const DataSizeSpecInfo &dataSizeInfo) const;
81     int GetDeletedSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength, Timestamp begin,
82         Timestamp end, const DataSizeSpecInfo &dataSizeInfo) const;
83 
84     int GetDeviceIdentifier(PragmaEntryDeviceIdentifier *identifier);
85 
86     int OpenResultSet(const Key &keyPrefix, int &count);
87 
88     int OpenResultSet(QueryObject &queryObj, int &count);
89 
90     int OpenResultSetForCacheRowIdMode(const Key &keyPrefix, std::vector<int64_t> &rowIdCache,
91         uint32_t cacheLimit, int &count);
92 
93     int OpenResultSetForCacheRowIdMode(QueryObject &queryObj, std::vector<int64_t> &rowIdCache,
94         uint32_t cacheLimit, int &count);
95 
96     int ReloadResultSet(const Key &keyPrefix);
97 
98     int ReloadResultSet(QueryObject &queryObj);
99 
100     int ReloadResultSetForCacheRowIdMode(const Key &keyPrefix, std::vector<int64_t> &rowIdCache,
101         uint32_t cacheLimit, uint32_t cacheStartPos);
102 
103     int ReloadResultSetForCacheRowIdMode(QueryObject &queryObj, std::vector<int64_t> &rowIdCache,
104         uint32_t cacheLimit, uint32_t cacheStartPos);
105 
106     int GetNextEntryFromResultSet(Key &key, Value &value, bool isCopy);
107 
108     int GetEntryByRowId(int64_t rowId, Entry &entry);
109 
110     void CloseResultSet();
111 
112     int StartTransaction(TransactType type);
113 
114     int Commit();
115 
116     int Rollback();
117 
118     bool CheckIfKeyExisted(const Key &key, bool isLocal, Value &value, Timestamp &timestamp) const;
119 
120     int PrepareForSavingData(SingleVerDataType type);
121 
122     int ResetForSavingData(SingleVerDataType type);
123 
124     int Reset() override;
125 
126     int UpdateLocalDataTimestamp(Timestamp timestamp);
127 
128     void SetAttachMetaMode(bool attachMetaMode);
129 
130     int PutLocalDataToCacheDB(const LocalDataItem &dataItem) const;
131 
132     int SaveSyncDataItemInCacheMode(DataItem &dataItem, const DeviceInfo &deviceInfo, Timestamp &maxStamp,
133         uint64_t recordVersion, const QueryObject &query);
134 
135     int PrepareForSavingCacheData(SingleVerDataType type);
136     int ResetForSavingCacheData(SingleVerDataType type);
137 
138     int MigrateLocalData();
139 
140     int MigrateSyncDataByVersion(uint64_t recordVer, NotifyMigrateSyncData &syncData,
141         std::vector<DataItem> &dataItems);
142     int GetMinVersionCacheData(std::vector<DataItem> &dataItems, uint64_t &minVerIncurCacheDb) const;
143 
144     int GetMaxVersionInCacheDb(uint64_t &maxVersion) const;
145     int AttachMainDbAndCacheDb(CipherType type, const CipherPassword &passwd,
146         const std::string &attachDbAbsPath, EngineState engineState);
147 
148     // Clear migrating data.
149     void ClearMigrateData();
150 
151     // Get current max timestamp.
152     int GetMaxTimestampDuringMigrating(Timestamp &maxTimestamp) const;
153 
154     void SetConflictResolvePolicy(int policy);
155 
156     // Delete multiple meta data records in a transaction.
157     int DeleteMetaData(const std::vector<Key> &keys);
158     // Delete multiple meta data records with key prefix in a transaction.
159     int DeleteMetaDataByPrefixKey(const Key &keyPrefix);
160 
161     int CheckIntegrity() const;
162 
163     int CheckQueryObjectLegal(QueryObject &queryObj) const;
164 
165     int CheckDataWithQuery(QueryObject query, std::vector<DataItem> &dataItems, const DeviceInfo &deviceInfo);
166 
167     static size_t GetDataItemSerialSize(const DataItem &item, size_t appendLen);
168 
169     int AddSubscribeTrigger(QueryObject &query, const std::string &subscribeId);
170 
171     int RemoveSubscribeTrigger(const std::vector<std::string> &subscribeIds);
172 
173     int RemoveSubscribeTriggerWaterMark(const std::vector<std::string> &subscribeIds);
174 
175     int GetTriggers(const std::string &namePreFix, std::vector<std::string> &triggerNames);
176 
177     int RemoveTrigger(const std::vector<std::string> &triggers);
178 
179     int GetSyncDataWithQuery(const QueryObject &query, size_t appendLength, const DataSizeSpecInfo &dataSizeInfo,
180         const std::pair<Timestamp, Timestamp> &timeRange, std::vector<DataItem> &dataItems) const;
181 
182     int ForceCheckPoint() const;
183 
184     uint64_t GetLogFileSize() const;
185 
186     int GetExistsDevicesFromMeta(std::set<std::string> &devices);
187 
188     int UpdateKey(const UpdateKeyCallback &callback);
189 
190     int CreateCloudLogTable();
191 
192     int GetEntries(const std::string &device, std::vector<Entry> &entries) const;
193 protected:
194     virtual int SaveKvData(SingleVerDataType type, const Key &key, const Value &value, Timestamp timestamp);
195 
196     virtual int DeleteLocalDataInner(SingleVerNaturalStoreCommitNotifyData *committedData,
197         const Key &key, const Value &value);
198 
199 private:
200     struct SaveRecordStatements {
201         sqlite3_stmt *queryStatement = nullptr;
202         sqlite3_stmt *insertStatement = nullptr;
203         sqlite3_stmt *updateStatement = nullptr;
204 
205         int ResetStatement();
206 
GetDataSaveStatementSaveRecordStatements207         inline sqlite3_stmt *GetDataSaveStatement(bool isUpdate) const
208         {
209             return isUpdate ? updateStatement : insertStatement;
210         }
211     };
212 
213     struct UpdateContext {
214         int errCode = E_OK;
215         Key newKey;
216         UpdateKeyCallback callback;
217     };
218 
219     void PutIntoCommittedData(const DataItem &itemPut, const DataItem &itemGet, const DataOperStatus &status,
220         SingleVerNaturalStoreCommitNotifyData *committedData);
221 
222     static int BindSavedSyncData(sqlite3_stmt *statement, const DataItem &dataItem, const Key &hashKey,
223         const SyncDataDevices &devices, bool isUpdate);
224 
225     static int BindDevForSavedSyncData(sqlite3_stmt *statement, const DataItem &dataItem, const std::string &origDev,
226         const std::string &deviceName);
227 
228     static void PutConflictData(const DataItem &itemPut, const DataItem &itemGet, const DeviceInfo &deviceInfo,
229         const DataOperStatus &dataStatus, SingleVerNaturalStoreCommitNotifyData *commitData);
230 
231     DataOperStatus JudgeSyncSaveType(DataItem &dataItem, const DataItem &itemGet,
232         const DeviceInfo &deviceInfo, bool isHashKeyExisted, bool isPermitForceWrite = true);
233 
234     static std::string GetOriginDevName(const DataItem &dataItem, const std::string &origDevGet);
235 
236     int GetSyncDataItemPre(const DataItem &itemPut, DataItem &itemGet, Key &hashKey) const;
237 
238     int GetSyncDataItemExt(const DataItem &dataItem, DataItem &itemGet, const DataOperStatus &dataStatus) const;
239 
240     int GetSyncDataPreByHashKey(const Key &hashKey, DataItem &itemGet) const;
241 
242     int PrepareForSyncDataByTime(Timestamp begin, Timestamp end, sqlite3_stmt *&statement, bool getDeletedData = false)
243         const;
244 
245     int StepForResultEntries(bool isGetValue, sqlite3_stmt *statement, std::vector<Entry> &entries) const;
246 
247     int InitResultSet(const Key &keyPrefix, sqlite3_stmt *&countStmt);
248 
249     int InitResultSetCount(QueryObject &queryObj, sqlite3_stmt *&countStmt);
250 
251     int InitResultSetContent(QueryObject &queryObj);
252 
253     int InitResultSet(QueryObject &queryObj, sqlite3_stmt *&countStmt);
254 
255     int GetAllEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const;
256 
257     int BindPutKvData(sqlite3_stmt *statement, const Key &key, const Value &value, Timestamp timestamp,
258         SingleVerDataType type);
259 
260     int SaveSyncDataToDatabase(const DataItem &dataItem, const Key &hashKey, const std::string &origDev,
261         const std::string &deviceName, bool isUpdate);
262 
263     int PrepareForSavingData(const std::string &readSql, const std::string &insertSql,
264         const std::string &updateSql, SaveRecordStatements &statements) const;
265 
266     int OpenResultSetForCacheRowIdModeCommon(std::vector<int64_t> &rowIdCache, uint32_t cacheLimit, int &count);
267 
268     int ResultSetLoadRowIdCache(std::vector<int64_t> &rowIdCache, uint32_t cacheLimit,
269         uint32_t cacheStartPos, int &count);
270 
271     void FinalizeAllStatements();
272     int ResetSaveSyncStatements(int errCode);
273 
274     int BindSyncDataInCacheMode(sqlite3_stmt *statement,
275         const DataItem &dataItem, const Key &hashKey, uint64_t recordVersion) const;
276 
277     int BindPrimaryKeySyncDataInCacheMode(
278         sqlite3_stmt *statement, const Key &hashKey, uint64_t recordVersion) const;
279 
280     int BindTimestampSyncDataInCacheMode(sqlite3_stmt *statement, const DataItem &dataItem) const;
281 
282     int BindDevSyncDataInCacheMode(sqlite3_stmt *statement,
283         const std::string &origDev, const std::string &deviceName) const;
284 
285     int SaveSyncDataToCacheDatabase(const DataItem &dataItem, const Key &hashKey, uint64_t recordVersion) const;
286 
287     int GetOneRawDataItem(sqlite3_stmt *statement, DataItem &dataItem,
288         uint64_t &verInCurCacheDb, bool isCacheDb) const;
289     int GetAllDataItems(sqlite3_stmt *statement, std::vector<DataItem> &dataItems,
290         uint64_t &verInCurCacheDb, bool isCacheDb) const;
291     int DelCacheDbDataByVersion(uint64_t version) const;
292 
293     // use for migrating data
294     int BindLocalDataInCacheMode(sqlite3_stmt *statement, const LocalDataItem &dataItem) const;
295 
296     // Process timestamp for syncdata in cacheDB when migrating.
297     int ProcessTimestampForSyncDataInCacheDB(std::vector<DataItem> &dataItems);
298 
299     // Get migrateTimeOffset_.
300     int InitMigrateTimestampOffset();
301 
302     // Get min timestamp of local data in sync_data, cacheDB.
303     int GetMinTimestampInCacheDB(Timestamp &minStamp) const;
304 
305     // Prepare conflict notify and commit notify data.
306     int PrepareForNotifyConflictAndObserver(DataItem &dataItem, const DeviceInfo &deviceInfo,
307         NotifyConflictAndObserverData &notify, bool isPermitForceWrite = true);
308 
309     // Put observer and conflict data into commit notify when migrating cacheDB.
310     int PutIntoConflictAndCommitForMigrateCache(DataItem &dataItem, const DeviceInfo &deviceInfo,
311         NotifyConflictAndObserverData &notify, bool isPermitForceWrite);
312 
313     int MigrateDataItems(std::vector<DataItem> &dataItems, NotifyMigrateSyncData &syncData);
314 
315     int MigrateDataItem(DataItem &dataItem, const NotifyMigrateSyncData &syncData);
316 
317     int GetEntriesForNotifyRemoveDevData(const DataItem &item, std::vector<Entry> &entries) const;
318 
319     // Reset migrateSyncStatements_.
320     int ResetForMigrateCacheData();
321 
322     // Init migrating data.
323     int InitMigrateData();
324 
325     int MigrateRmDevData(const DataItem &dataItem) const;
326     int VacuumLocalData() const;
327 
328     int GetSyncDataItems(std::vector<DataItem> &dataItems, sqlite3_stmt *statement,
329         size_t appendLength, const DataSizeSpecInfo &dataSizeInfo) const;
330 
331     int GetSyncDataWithQuery(sqlite3_stmt *fullStmt, sqlite3_stmt *queryStmt,
332         size_t appendLength, const DataSizeSpecInfo &dataSizeInfo, std::vector<DataItem> &dataItems) const;
333 
334     int CheckMissQueryDataItems(sqlite3_stmt *&stmt, const SqliteQueryHelper &helper, const DeviceInfo &deviceInfo,
335         std::vector<DataItem> &dataItems);
336 
337     int CheckDataWithQuery(std::vector<DataItem> &dataItems);
338 
339     int GetExpandedCheckSql(QueryObject query, DataItem &dataItem);
340 
341     int CheckMissQueryDataItem(sqlite3_stmt *stmt, const std::string &deviceName, DataItem &item);
342 
343     int CreateFuncUpdateKey(UpdateContext &context,
344         void(*translateFunc)(sqlite3_context *ctx, int argc, sqlite3_value **argv),
345         void(*calHashFunc)(sqlite3_context *ctx, int argc, sqlite3_value **argv)) const;
346 
347     static void Translate(sqlite3_context *ctx, int argc, sqlite3_value **argv);
348 
349     static void CalHashKey(sqlite3_context *ctx, int argc, sqlite3_value **argv);
350 
351     static int BindSyncDataTime(sqlite3_stmt *statement, const DataItem &dataItem, bool isUpdate);
352 
353     int CloudExcuteRemoveOrUpdate(const std::string &sql, const std::string &deviceName, const std::string &user,
354         bool isUserBlobType = false);
355 
356     int CloudCheckDataExist(const std::string &sql, const std::string &deviceName, const std::string &user,
357         bool &isExist);
358 
359     int RemoveDeviceDataInner(ClearMode mode);
360 
361     int RemoveDeviceDataInner(const std::string &deviceName, ClearMode mode);
362 
363     int RemoveDeviceDataWithUserInner(const std::string &user, ClearMode mode);
364 
365     int RemoveDeviceDataWithUserInner(const std::string &deviceName, const std::string &user, ClearMode mode);
366 
367     int RemoveCloudUploadFlag(const std::vector<uint8_t> &hashKey);
368 
369     bool IsFromDataOwner(const DataItem &itemGet, const std::string &syncDev);
370     sqlite3_stmt *getSyncStatement_;
371     sqlite3_stmt *getResultRowIdStatement_;
372     sqlite3_stmt *getResultEntryStatement_;
373     SaveRecordStatements saveSyncStatements_;
374     SaveRecordStatements saveLocalStatements_;
375 
376     // Used for migrating sync_data.
377     SaveRecordStatements migrateSyncStatements_;
378     bool isTransactionOpen_;
379     bool attachMetaMode_; // true for attach meta mode
380     ExecutorState executorState_;
381 
382     // Max timestamp in mainDB. Used for migrating.
383     Timestamp maxTimestampInMainDB_;
384 
385     // The offset between min timestamp in cacheDB and max timestamp in mainDB. Used for migrating.
386     TimeOffset migrateTimeOffset_;
387 
388     // Migrating sync flag. When the flag is true, mainDB and cacheDB are attached, migrateSyncStatements_ is set,
389     // maxTimestampInMainDB_ and migrateTimeOffset_ is meaningful.
390     bool isSyncMigrating_;
391     int conflictResolvePolicy_;
392 };
393 } // namespace DistributedDB
394 
395 #endif // SQLITE_SINGLE_VER_STORAGE_EXECUTOR_H
396