diff --git a/frameworks/libs/distributeddb/common/include/cloud/asset_operation_utils.h b/frameworks/libs/distributeddb/common/include/cloud/asset_operation_utils.h index a6bde9e13c93ba62ed65ca5acce1b6c9a87cd6c2..3f15778a073dacdf1976fc47179b3e845397b7f0 100644 --- a/frameworks/libs/distributeddb/common/include/cloud/asset_operation_utils.h +++ b/frameworks/libs/distributeddb/common/include/cloud/asset_operation_utils.h @@ -15,6 +15,7 @@ #ifndef ASSET_OPERATION_UTILS_H #define ASSET_OPERATION_UTILS_H +#include "cloud/cloud_db_types.h" #include "cloud/cloud_store_types.h" namespace DistributedDB { @@ -32,25 +33,26 @@ public: DEFAULT_ACTION }; using RecordAssetOpType = std::map>; - static RecordAssetOpType CalAssetOperation(const VBucket &cacheAssets, const VBucket &dbAssets, + static RecordAssetOpType CalAssetOperation(const AssetTypeMap &cacheAssets, const VBucket &dbAssets, const CloudSyncAction &action); - static AssetOperationUtils::AssetOpType CalAssetOperation(const std::string &colName, const Asset &cacheAsset, + static AssetOperationUtils::AssetOpType CalAssetOperation(const std::string &colName, const TempAsset &cacheAsset, const VBucket &dbAssets, const CloudSyncAction &action); static uint32_t EraseBitMask(uint32_t status); - static void UpdateAssetsFlag(std::vector &from, std::vector &target); + static void UpdateAssetsStatus(std::vector &from, std::vector &target); static void FilterDeleteAsset(VBucket &record); private: static void Init(); - static AssetOperationUtils::AssetOpType DefaultOperation(const Asset &, const Assets &); - static AssetOperationUtils::AssetOpType CheckBeforeDownload(const Asset &cacheAsset, const Assets &dbAssets); - static AssetOperationUtils::AssetOpType CheckAfterDownload(const Asset &cacheAsset, const Assets &dbAssets); - static AssetOperationUtils::AssetOpType CheckWithDownload(bool before, const Asset &cacheAsset, + static AssetOperationUtils::AssetOpType DefaultOperation(const TempAsset &, const Assets &); + static AssetOperationUtils::AssetOpType CheckBeforeDownload(const TempAsset &cacheAsset, const Assets &dbAssets); + static AssetOperationUtils::AssetOpType CheckAfterDownload(const TempAsset &cacheAsset, const Assets &dbAssets); + static AssetOperationUtils::AssetOpType CheckWithDownload(bool before, const TempAsset &cacheAsset, const Assets &dbAssets); - static AssetOperationUtils::AssetOpType CheckAfterUpload(const Asset &cacheAsset, const Assets &dbAssets); - static AssetOperationUtils::AssetOpType HandleIfExistAndSameStatus(const Asset &cacheAsset, const Assets &dbAssets); + static AssetOperationUtils::AssetOpType CheckAfterUpload(const TempAsset &cacheAsset, const Assets &dbAssets); + static AssetOperationUtils::AssetOpType HandleIfExistAndSameStatus(const TempAsset &cacheAsset, const Assets &dbAssets); static Assets GetAssets(const std::string &colName, const VBucket &rowData); - static void MergeAssetsFlag(const Assets &from, Type &target); - static void MergeAssetFlag(const Assets &from, Asset &target); + static TempAssets GetAssets(const std::string &colName, const AssetTypeMap &rowData); + static void MergeAssetsStatus(const Assets &from, Type &target); + static void MergeAssetStatus(const Assets &from, Asset &target); static constexpr uint32_t BIT_MASK_COUNT = 16; }; } diff --git a/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h b/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h index 3f957a079d430aec67e278d484c0b412ce718682..73c6f46e3e270c8ee40174debd3982ef79de9fa8 100644 --- a/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h +++ b/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h @@ -20,6 +20,26 @@ #include namespace DistributedDB { + +struct TempAsset { + uint32_t version = 0; + std::string name; + std::string assetId; + std::string subpath; + std::string uri; + std::string modifyTime; + std::string createTime; + std::string size; + std::string hash; + uint32_t flag = static_cast(AssetOpType::NO_CHANGE); + uint32_t status = static_cast(AssetStatus::NORMAL); + int64_t timestamp = 0; +}; + +using TempAssets = std::vector; +using AssetType = std::variant; +using AssetTypeMap = std::map; + struct CloudSyncBatch { std::vector record; std::vector extend; @@ -27,6 +47,7 @@ struct CloudSyncBatch { std::vector timestamp; std::vector assets; std::vector hashKey; + std::vector tempAssets; }; struct CloudSyncData { @@ -75,6 +96,10 @@ template inline constexpr static int32_t TYPE_INDEX = decltype(variant_index_test(std::declval(), std::declval()))::value; +template +inline constexpr static int32_t ASSET_INDEX = + decltype(variant_index_test(std::declval(), std::declval()))::value; + inline constexpr static int32_t TYPE_MAX = decltype(variant_size_test(std::declval()))::value; } // namespace DistributedDB diff --git a/frameworks/libs/distributeddb/common/src/cloud/asset_operation_utils.cpp b/frameworks/libs/distributeddb/common/src/cloud/asset_operation_utils.cpp index 98d084798b3beff26eb3ce47783b08304a1cdc48..db3507613419f65c0f8d1ab66f68ea05e91c13a5 100644 --- a/frameworks/libs/distributeddb/common/src/cloud/asset_operation_utils.cpp +++ b/frameworks/libs/distributeddb/common/src/cloud/asset_operation_utils.cpp @@ -22,7 +22,7 @@ using RecordAssetOpType = AssetOperationUtils::RecordAssetOpType; using CloudSyncAction = AssetOperationUtils::CloudSyncAction; namespace { std::once_flag init; -using Reaction = std::function; +using Reaction = std::function; std::map reactions; Reaction GetReaction(const CloudSyncAction &action) { @@ -34,7 +34,7 @@ Reaction GetReaction(const CloudSyncAction &action) } } -RecordAssetOpType AssetOperationUtils::CalAssetOperation(const VBucket &cacheAssets, +RecordAssetOpType AssetOperationUtils::CalAssetOperation(const AssetTypeMap &cacheAssets, const VBucket &dbAssets, const CloudSyncAction &action) { std::call_once(init, Init); @@ -44,11 +44,11 @@ RecordAssetOpType AssetOperationUtils::CalAssetOperation(const VBucket &cacheAss // check each cache asset with db asset by same col name and asset name for (const auto &[colName, colData] : cacheAssets) { auto checkAssets = GetAssets(colName, dbAssets); - if (TYPE_INDEX == colData.index()) { - auto asset = std::get(colData); + if (ASSET_INDEX == colData.index()) { + auto asset = std::get(colData); res[colName][asset.name] = reaction(asset, checkAssets); - } else if (TYPE_INDEX == colData.index()) { - auto assets = std::get(colData); + } else if (ASSET_INDEX == colData.index()) { + auto assets = std::get(colData); for (const auto &asset : assets) { res[colName][asset.name] = reaction(asset, checkAssets); } @@ -58,7 +58,7 @@ RecordAssetOpType AssetOperationUtils::CalAssetOperation(const VBucket &cacheAss } AssetOperationUtils::AssetOpType AssetOperationUtils::CalAssetOperation(const std::string &colName, - const Asset &cacheAsset, const VBucket &dbAssets, const AssetOperationUtils::CloudSyncAction &action) + const TempAsset &cacheAsset, const VBucket &dbAssets, const AssetOperationUtils::CloudSyncAction &action) { std::call_once(init, Init); // switch produce function by action @@ -71,7 +71,7 @@ uint32_t AssetOperationUtils::EraseBitMask(uint32_t status) return ((status << BIT_MASK_COUNT) >> BIT_MASK_COUNT); } -void AssetOperationUtils::UpdateAssetsFlag(std::vector &from, std::vector &target) +void AssetOperationUtils::UpdateAssetsStatus(std::vector &from, std::vector &target) { if (from.size() != target.size()) { LOGE("the num of VBucket are not equal when update assets flag."); @@ -85,7 +85,7 @@ void AssetOperationUtils::UpdateAssetsFlag(std::vector &from, std::vect } for (auto &[colName, colData] : targetRecord) { auto fromAssets = GetAssets(colName, fromRecord); - MergeAssetsFlag(fromAssets, colData); + MergeAssetsStatus(fromAssets, colData); } } } @@ -129,24 +129,24 @@ void AssetOperationUtils::Init() reactions[CloudSyncAction::END_UPLOAD] = CheckAfterUpload; } -AssetOperationUtils::AssetOpType AssetOperationUtils::DefaultOperation(const Asset &, const Assets &) +AssetOperationUtils::AssetOpType AssetOperationUtils::DefaultOperation(const TempAsset &, const Assets &) { return AssetOpType::HANDLE; } -AssetOperationUtils::AssetOpType AssetOperationUtils::CheckBeforeDownload(const Asset &cacheAsset, +AssetOperationUtils::AssetOpType AssetOperationUtils::CheckBeforeDownload(const TempAsset &cacheAsset, const Assets &dbAssets) { return CheckWithDownload(true, cacheAsset, dbAssets); } -AssetOperationUtils::AssetOpType AssetOperationUtils::CheckAfterDownload(const Asset &cacheAsset, +AssetOperationUtils::AssetOpType AssetOperationUtils::CheckAfterDownload(const TempAsset &cacheAsset, const Assets &dbAssets) { return CheckWithDownload(false, cacheAsset, dbAssets); } -AssetOperationUtils::AssetOpType AssetOperationUtils::CheckWithDownload(bool before, const Asset &cacheAsset, +AssetOperationUtils::AssetOpType AssetOperationUtils::CheckWithDownload(bool before, const TempAsset &cacheAsset, const Assets &dbAssets) { for (const auto &dbAsset : dbAssets) { @@ -170,7 +170,8 @@ AssetOperationUtils::AssetOpType AssetOperationUtils::CheckWithDownload(bool bef return AssetOpType::NOT_HANDLE; } -AssetOperationUtils::AssetOpType AssetOperationUtils::CheckAfterUpload(const Asset &cacheAsset, const Assets &dbAssets) +AssetOperationUtils::AssetOpType AssetOperationUtils::CheckAfterUpload(const TempAsset &cacheAsset, + const Assets &dbAssets) { for (const auto &dbAsset : dbAssets) { if (dbAsset.name != cacheAsset.name) { @@ -202,7 +203,24 @@ Assets AssetOperationUtils::GetAssets(const std::string &colName, const VBucket return res; } -AssetOperationUtils::AssetOpType AssetOperationUtils::HandleIfExistAndSameStatus(const Asset &cacheAsset, +TempAssets AssetOperationUtils::GetAssets(const std::string &colName, const AssetTypeMap &rowData) +{ + if (rowData.find(colName) == rowData.end()) { + return {}; + } + TempAssets res; + auto value = rowData.at(colName); + if (ASSET_INDEX == value.index()) { + res.push_back(std::get(value)); + } else if (ASSET_INDEX == value.index()) { + for (const auto &asset : std::get(value)) { + res.push_back(asset); + } + } + return res; +} + +AssetOperationUtils::AssetOpType AssetOperationUtils::HandleIfExistAndSameStatus(const TempAsset &cacheAsset, const Assets &dbAssets) { for (const auto &dbAsset : dbAssets) { @@ -217,22 +235,22 @@ AssetOperationUtils::AssetOpType AssetOperationUtils::HandleIfExistAndSameStatus return AssetOpType::NOT_HANDLE; } -void AssetOperationUtils::MergeAssetsFlag(const Assets &from, Type &target) +void AssetOperationUtils::MergeAssetsStatus(const Assets &from, Type &target) { if (TYPE_INDEX == target.index()) { - MergeAssetFlag(from, std::get(target)); + MergeAssetStatus(from, std::get(target)); } else if (TYPE_INDEX == target.index()) { for (auto &targetAsset : std::get(target)) { - MergeAssetFlag(from, targetAsset); + MergeAssetStatus(from, targetAsset); } } } -void AssetOperationUtils::MergeAssetFlag(const Assets &from, Asset &target) +void AssetOperationUtils::MergeAssetStatus(const Assets &from, Asset &target) { for (const auto &fromAsset : from) { if (fromAsset.name == target.name) { - target.flag = fromAsset.flag; + target.status = fromAsset.status; } } } diff --git a/frameworks/libs/distributeddb/interfaces/include/cloud/cloud_store_types.h b/frameworks/libs/distributeddb/interfaces/include/cloud/cloud_store_types.h index ca5138b3f80c958a089587caf1e80f2e820e75be..3324f69092d5f54225aa6a94bb81df0da3a57ade 100644 --- a/frameworks/libs/distributeddb/interfaces/include/cloud/cloud_store_types.h +++ b/frameworks/libs/distributeddb/interfaces/include/cloud/cloud_store_types.h @@ -68,7 +68,6 @@ struct Asset { std::string createTime; std::string size; std::string hash; - uint32_t flag = static_cast(AssetOpType::NO_CHANGE); uint32_t status = static_cast(AssetStatus::NORMAL); int64_t timestamp = 0; }; diff --git a/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h b/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h index 341b83a17f70463f91759284d8f806b5eaa71866..911c80b531398d067c14c3f43a773e1a9f1b8228 100644 --- a/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h +++ b/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h @@ -34,6 +34,12 @@ public: return DBStatus::OK; } + virtual DBStatus RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix, + const std::map &assets) + { + return DBStatus::OK; + } + virtual DBStatus RemoveLocalAssets(const std::vector &assets) { return DBStatus::OK; diff --git a/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h b/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h index b9794aef86f077fe40dc5f3fc0f8b964f55c0745..e91b4fea59298320e1adb7bda1ecdd2dd5e3a7a5 100644 --- a/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h +++ b/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h @@ -168,7 +168,8 @@ public: int CleanCloudData(ClearMode mode, const std::vector &tableNameList, const RelationalSchemaObject &localSchema, std::vector &assets) override; - int FillCloudAssetForDownload(const std::string &tableName, VBucket &asset, bool isDownloadSuccess) override; + int FillCloudAssetForDownload(const std::string &tableName, const std::string &gid, AssetTypeMap &asset, + bool isDownloadSuccess) override; int SetLogTriggerStatus(bool status) override; diff --git a/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h b/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h index 074663b8fd2603f5dabe583e00ef27e3c39025c4..be81ad787ad8c0896ad032743eb134dccc9e2c14 100644 --- a/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h +++ b/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h @@ -55,41 +55,47 @@ public: static std::vector GetCloudAsset(const TableSchema &tableSchema); static int GetAssetFieldsFromSchema(const TableSchema &tableSchema, const VBucket &vBucket, std::vector &fields); + static int GetAssetFieldsFromSchema(const TableSchema &tableSchema, const AssetTypeMap &assetTypeMap, + std::vector &fields); static void ObtainAssetFromVBucket(const VBucket &vBucket, VBucket &asset); static AssetOpType StatusToFlag(AssetStatus status); static AssetStatus FlagToStatus(AssetOpType opType); - static void ChangeAssetsOnVBucketToAsset(VBucket &vBucket, std::vector &fields); - static Type GetAssetFromAssets(Type &value); - static int FillAssetBeforeDownload(Asset &asset); - static int FillAssetAfterDownloadFail(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); - static void FillAssetsAfterDownloadFail(Assets &assets, Assets &dbAssets, + static void ChangeAssetsOnVBucketToAsset(AssetTypeMap &assetTypeMap, std::vector &fields); + static AssetType GetAssetFromAssets(AssetType &value); + static int FillAssetBeforeDownload(TempAsset &asset); + static int FillAssetAfterDownloadFail(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); + static void FillAssetsAfterDownloadFail(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap); - static void MergeAssetWithFillFunc(Assets &assets, Assets &dbAssets, const std::map &assetOpTypeMap, - std::function fillAsset); - static int FillAssetAfterDownload(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); - static void FillAssetsAfterDownload(Assets &assets, Assets &dbAssets, + std::function fillAsset); + static int FillAssetAfterDownload(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); + static void FillAssetsAfterDownload(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap); - static int FillAssetBeforeUpload(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); - static void FillAssetsBeforeUpload(Assets &assets, Assets &dbAssets, + static int FillAssetBeforeUpload(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); + static void FillAssetsBeforeUpload(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap); - static int FillAssetForUpload(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); - static void FillAssetsForUpload(Assets &assets, Assets &dbAssets, + static int FillAssetForUpload(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); + static void FillAssetsForUpload(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap); - static int FillAssetForUploadFailed(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); - static void FillAssetsForUploadFailed(Assets &assets, Assets &dbAssets, + static int FillAssetForUploadFailed(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType); + static void FillAssetsForUploadFailed(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap); - static void PrepareToFillAssetFromVBucket(VBucket &vBucket, std::function fillAsset); - static void FillAssetFromVBucketFinish(const AssetOperationUtils::RecordAssetOpType &assetOpType, VBucket &vBucket, - VBucket &dbAssets, std::function fillAsset, - std::function fillAsset); + static void FillAssetFromVBucketFinish(const AssetOperationUtils::RecordAssetOpType &assetOpType, + AssetTypeMap &assetTypeMap, VBucket &dbAssets, + std::function fillAsset, + std::function &)> fillAssets); static bool IsAsset(const Type &type); static bool IsAssets(const Type &type); + static bool IsAssetType(const AssetType &type); + static bool IsAssetsType(const AssetType &type); static bool IsAssetsContainDuplicateAsset(Assets &assets); - static void EraseNoChangeAsset(std::map &assetsMap); + static void EraseNoChangeAsset(std::map &assetsMap); static void MergeDownloadAsset(std::map &downloadAssets, std::map &mergeAssets); + static std::map GenAssetsIndexMap(TempAssets &assets); static std::map GenAssetsIndexMap(Assets &assets); static bool IsVbucketContainsAllPK(const VBucket &vBucket, const std::set &pkSet); static bool CheckAssetStatus(const Assets &assets); @@ -139,6 +145,17 @@ public: return E_OK; } + template + static int GetValueFromAssetType(AssetType &cloudValue, T &outVal) + { + T *value = std::get_if(&cloudValue); + if (value == nullptr) { + return -E_CLOUD_ERROR; + } + outVal = *value; + return E_OK; + } + static int CalculateHashKeyForOneField(const Field &field, const VBucket &vBucket, bool allowEmpty, CollateType collateType, std::vector &hashValue); diff --git a/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h b/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h index 5116bbe1676e043e81953dbff3b2f70cb0c0bdb1..fe96fe149929af0b42655424dc02fda43c03ebff 100644 --- a/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h +++ b/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h @@ -44,6 +44,7 @@ typedef struct DownloadData { std::vector data; std::vector opType; std::vector existDataKey; + std::vector tempAssets; } DownloadData; class ICloudSyncStorageInterface { @@ -93,7 +94,8 @@ public: virtual void TriggerObserverAction(const std::string &deviceName, ChangedData &&changedData, bool isChangedData) = 0; - virtual int FillCloudAssetForDownload(const std::string &tableName, VBucket &asset, bool isDownloadSuccess) = 0; + virtual int FillCloudAssetForDownload(const std::string &tableName, const std::string &gid, AssetTypeMap &asset, + bool isDownloadSuccess) = 0; virtual int SetLogTriggerStatus(bool status) = 0; diff --git a/frameworks/libs/distributeddb/storage/include/storage_proxy.h b/frameworks/libs/distributeddb/storage/include/storage_proxy.h index 42151941a6af899c54d755fbfe5141816dda8134..9119da15e665eb1193b7c21a648cb27449cd187d 100644 --- a/frameworks/libs/distributeddb/storage/include/storage_proxy.h +++ b/frameworks/libs/distributeddb/storage/include/storage_proxy.h @@ -88,7 +88,8 @@ public: int ReleaseContinueToken(ContinueToken &continueStmtToken); - int FillCloudAssetForDownload(const std::string &tableName, VBucket &asset, bool isDownloadSuccess); + int FillCloudAssetForDownload(const std::string &tableName, const std::string &gid, AssetTypeMap &asset, + bool isDownloadSuccess); int SetLogTriggerStatus(bool status); diff --git a/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp b/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp index fbf0598b3bf24a375f89bbbf4ed00acbb5cc6315..d19d0e3c3ae8e7c2370a23b010d83bbe126f0bee 100644 --- a/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp +++ b/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp @@ -18,6 +18,7 @@ #include "cloud/asset_operation_utils.h" #include "cloud/cloud_db_types.h" +#include "cloud/cloud_sync_utils.h" #include "db_common.h" #include "runtime_context.h" @@ -352,6 +353,25 @@ int CloudStorageUtils::GetAssetFieldsFromSchema(const TableSchema &tableSchema, return E_OK; } +int CloudStorageUtils::GetAssetFieldsFromSchema(const TableSchema &tableSchema, const AssetTypeMap &assetTypeMap, + std::vector &fields) +{ + for (const auto &field: tableSchema.fields) { + auto it = assetTypeMap.find(field.colName); + if (it == assetTypeMap.end()) { + continue; + } + if (it->second.index() != ASSET_INDEX && it->second.index() != ASSET_INDEX) { + continue; + } + fields.push_back(field); + } + if (fields.empty()) { + return -E_CLOUD_ERROR; + } + return E_OK; +} + bool CloudStorageUtils::IsContainsPrimaryKey(const TableSchema &tableSchema) { for (const auto &field : tableSchema.fields) { @@ -403,31 +423,31 @@ AssetStatus CloudStorageUtils::FlagToStatus(AssetOpType opType) } } -void CloudStorageUtils::ChangeAssetsOnVBucketToAsset(VBucket &vBucket, std::vector &fields) +void CloudStorageUtils::ChangeAssetsOnVBucketToAsset(AssetTypeMap &assetTypeMap, std::vector &fields) { for (const Field &field: fields) { if (field.type == TYPE_INDEX) { - Type asset = GetAssetFromAssets(vBucket[field.colName]); - vBucket[field.colName] = asset; + AssetType asset = GetAssetFromAssets(assetTypeMap[field.colName]); + assetTypeMap[field.colName] = asset; } } } -Type CloudStorageUtils::GetAssetFromAssets(Type &value) +AssetType CloudStorageUtils::GetAssetFromAssets(AssetType &value) { - Asset assetVal; - int errCode = GetValueFromType(value, assetVal); + TempAsset assetVal; + int errCode = GetValueFromAssetType(value, assetVal); if (errCode == E_OK) { return assetVal; } - Assets assets; - errCode = GetValueFromType(value, assets); + TempAssets assets; + errCode = GetValueFromAssetType(value, assets); if (errCode != E_OK) { return Nil(); } - for (Asset &asset: assets) { + for (TempAsset &asset: assets) { if (asset.flag != static_cast(AssetOpType::DELETE)) { return std::move(asset); } @@ -435,7 +455,7 @@ Type CloudStorageUtils::GetAssetFromAssets(Type &value) return Nil(); } -int CloudStorageUtils::FillAssetBeforeDownload(Asset &asset) +int CloudStorageUtils::FillAssetBeforeDownload(TempAsset &asset) { AssetOpType flag = static_cast(asset.flag); AssetStatus status = static_cast(asset.status); @@ -458,13 +478,13 @@ int CloudStorageUtils::FillAssetBeforeDownload(Asset &asset) return E_OK; } -int CloudStorageUtils::FillAssetAfterDownload(Asset &asset, Asset &dbAsset, +int CloudStorageUtils::FillAssetAfterDownload(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) { if (assetOpType == AssetOperationUtils::AssetOpType::NOT_HANDLE) { return E_OK; } - dbAsset = asset; + CloudSyncUtils::CopyTempAssetToAsset(asset, dbAsset); AssetOpType flag = static_cast(asset.flag); if (asset.status != AssetStatus::NORMAL) { return E_OK; @@ -479,13 +499,13 @@ int CloudStorageUtils::FillAssetAfterDownload(Asset &asset, Asset &dbAsset, return E_OK; } -void CloudStorageUtils::FillAssetsAfterDownload(Assets &assets, Assets &dbAssets, +void CloudStorageUtils::FillAssetsAfterDownload(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap) { MergeAssetWithFillFunc(assets, dbAssets, assetOpTypeMap, FillAssetAfterDownload); } -int CloudStorageUtils::FillAssetForUpload(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) +int CloudStorageUtils::FillAssetForUpload(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) { if (assetOpType == AssetOperationUtils::AssetOpType::NOT_HANDLE) { // db assetId may be empty, need to be based on cache @@ -493,7 +513,7 @@ int CloudStorageUtils::FillAssetForUpload(Asset &asset, Asset &dbAsset, AssetOpe return E_OK; } AssetStatus status = static_cast(dbAsset.status); - dbAsset = asset; + CloudSyncUtils::CopyTempAssetToAsset(asset, dbAsset); switch (StatusToFlag(status)) { case AssetOpType::INSERT: case AssetOpType::UPDATE: @@ -508,22 +528,21 @@ int CloudStorageUtils::FillAssetForUpload(Asset &asset, Asset &dbAsset, AssetOpe break; } } - dbAsset.flag = static_cast(AssetOpType::NO_CHANGE); return E_OK; } -void CloudStorageUtils::FillAssetsForUpload(Assets &assets, Assets &dbAssets, +void CloudStorageUtils::FillAssetsForUpload(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap) { MergeAssetWithFillFunc(assets, dbAssets, assetOpTypeMap, FillAssetForUpload); } -int CloudStorageUtils::FillAssetBeforeUpload(Asset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) +int CloudStorageUtils::FillAssetBeforeUpload(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) { if (assetOpType == AssetOperationUtils::AssetOpType::NOT_HANDLE) { return E_OK; } - dbAsset = asset; + CloudSyncUtils::CopyTempAssetToAsset(asset, dbAsset); switch (static_cast(asset.flag)) { case AssetOpType::INSERT: case AssetOpType::UPDATE: @@ -534,45 +553,45 @@ int CloudStorageUtils::FillAssetBeforeUpload(Asset &asset, Asset &dbAsset, Asset default: break; } - dbAsset.flag = static_cast(AssetOpType::NO_CHANGE); return E_OK; } -void CloudStorageUtils::FillAssetsBeforeUpload(Assets &assets, Assets &dbAssets, const std::map &assetOpTypeMap) { MergeAssetWithFillFunc(assets, dbAssets, assetOpTypeMap, FillAssetBeforeUpload); } -void CloudStorageUtils::PrepareToFillAssetFromVBucket(VBucket &vBucket, std::function fillAsset) +void CloudStorageUtils::PrepareToFillAssetFromVBucket(AssetTypeMap &assetTypeMap, + std::function fillAsset) { - for (auto &item: vBucket) { - if (IsAsset(item.second)) { - Asset asset; - GetValueFromType(item.second, asset); + for (auto &item: assetTypeMap) { + if (IsAssetType(item.second)) { + TempAsset asset; + GetValueFromAssetType(item.second, asset); fillAsset(asset); - vBucket[item.first] = asset; - } else if (IsAssets(item.second)) { - Assets assets; - GetValueFromType(item.second, assets); + assetTypeMap[item.first] = asset; + } else if (IsAssetsType(item.second)) { + TempAssets assets; + GetValueFromAssetType(item.second, assets); for (auto it = assets.begin(); it != assets.end();) { fillAsset(*it) == -E_NOT_FOUND ? it = assets.erase(it) : ++it; } - vBucket[item.first] = assets; + assetTypeMap[item.first] = assets; } } } void CloudStorageUtils::FillAssetFromVBucketFinish(const AssetOperationUtils::RecordAssetOpType &assetOpType, - VBucket &vBucket, VBucket &dbAssets, - std::function fillAsset, - std::function fillAsset, + std::function &)> fillAssets) { for (auto &item: dbAssets) { if (IsAsset(item.second)) { - Asset cacheItem; - GetValueFromType(vBucket[item.first], cacheItem); + TempAsset cacheItem; + GetValueFromAssetType(assetTypeMap[item.first], cacheItem); Asset dbItem; GetValueFromType(item.second, dbItem); AssetOperationUtils::AssetOpType opType = AssetOperationUtils::AssetOpType::NOT_HANDLE; @@ -589,8 +608,8 @@ void CloudStorageUtils::FillAssetFromVBucketFinish(const AssetOperationUtils::Re continue; } if (IsAssets(item.second)) { - Assets cacheItems; - GetValueFromType(vBucket[item.first], cacheItems); + TempAssets cacheItems; + GetValueFromAssetType(assetTypeMap[item.first], cacheItems); Assets dbItems; GetValueFromType(item.second, dbItems); auto iterCol = assetOpType.find(item.first); @@ -618,6 +637,16 @@ bool CloudStorageUtils::IsAssets(const Type &type) return type.index() == TYPE_INDEX; } +bool CloudStorageUtils::IsAssetType(const AssetType &type) +{ + return type.index() == ASSET_INDEX; +} + +bool CloudStorageUtils::IsAssetsType(const AssetType &type) +{ + return type.index() == ASSET_INDEX; +} + int CloudStorageUtils::CalculateHashKeyForOneField(const Field &field, const VBucket &vBucket, bool allowEmpty, CollateType collateType, std::vector &hashValue) { @@ -661,7 +690,7 @@ bool CloudStorageUtils::IsAssetsContainDuplicateAsset(Assets &assets) return false; } -void CloudStorageUtils::EraseNoChangeAsset(std::map &assetsMap) +void CloudStorageUtils::EraseNoChangeAsset(std::map &assetsMap) { for (auto items = assetsMap.begin(); items != assetsMap.end();) { for (auto item = items->second.begin(); item != items->second.end();) { @@ -698,6 +727,16 @@ void CloudStorageUtils::MergeDownloadAsset(std::map &downlo } } +std::map CloudStorageUtils::GenAssetsIndexMap(TempAssets &assets) +{ + // key of assetsIndexMap is name of asset, the value of it is index. + std::map assetsIndexMap; + for (size_t i = 0; i < assets.size(); i++) { + assetsIndexMap[assets[i].name] = i; + } + return assetsIndexMap; +} + std::map CloudStorageUtils::GenAssetsIndexMap(Assets &assets) { // key of assetsIndexMap is name of asset, the value of it is index. @@ -889,7 +928,7 @@ void CloudStorageUtils::GetToBeRemoveAssets(const VBucket &vBucket, } } -int CloudStorageUtils::FillAssetForUploadFailed(Asset &asset, Asset &dbAsset, +int CloudStorageUtils::FillAssetForUploadFailed(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) { dbAsset.assetId = asset.assetId; @@ -897,13 +936,13 @@ int CloudStorageUtils::FillAssetForUploadFailed(Asset &asset, Asset &dbAsset, return E_OK; } -void CloudStorageUtils::FillAssetsForUploadFailed(Assets &assets, Assets &dbAssets, +void CloudStorageUtils::FillAssetsForUploadFailed(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap) { MergeAssetWithFillFunc(assets, dbAssets, assetOpTypeMap, FillAssetForUploadFailed); } -int CloudStorageUtils::FillAssetAfterDownloadFail(Asset &asset, Asset &dbAsset, +int CloudStorageUtils::FillAssetAfterDownloadFail(TempAsset &asset, Asset &dbAsset, AssetOperationUtils::AssetOpType assetOpType) { AssetStatus status = static_cast(asset.status); @@ -914,7 +953,7 @@ int CloudStorageUtils::FillAssetAfterDownloadFail(Asset &asset, Asset &dbAsset, return FillAssetAfterDownload(asset, dbAsset, assetOpType); } AssetOpType flag = static_cast(asset.flag); - dbAsset = asset; + CloudSyncUtils::CopyTempAssetToAsset(asset, dbAsset); switch (flag) { case AssetOpType::INSERT: case AssetOpType::DELETE: @@ -929,19 +968,19 @@ int CloudStorageUtils::FillAssetAfterDownloadFail(Asset &asset, Asset &dbAsset, return E_OK; } -void CloudStorageUtils::FillAssetsAfterDownloadFail(Assets &assets, Assets &dbAssets, +void CloudStorageUtils::FillAssetsAfterDownloadFail(TempAssets &assets, Assets &dbAssets, const std::map &assetOpTypeMap) { MergeAssetWithFillFunc(assets, dbAssets, assetOpTypeMap, FillAssetAfterDownloadFail); } -void CloudStorageUtils::MergeAssetWithFillFunc(Assets &assets, Assets &dbAssets, const std::map &assetOpTypeMap, - std::function fillAsset) + std::function fillAsset) { std::map indexMap = GenAssetsIndexMap(assets); for (auto dbAsset = dbAssets.begin(); dbAsset != dbAssets.end();) { - Asset cacheAsset; + TempAsset cacheAsset; auto it = indexMap.find(dbAsset->name); if (it != indexMap.end()) { cacheAsset = assets[it->second]; diff --git a/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp b/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp index 035af4fa27d9ad88dd96f2f40da4ba414cccbf41..35f55ccfa01399624264643218735990b86c0743 100644 --- a/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp +++ b/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp @@ -19,6 +19,7 @@ #include "cloud/cloud_db_constant.h" #include "cloud/cloud_storage_utils.h" +#include "cloud/cloud_sync_utils.h" #include "concurrent_adapter.h" #include "data_compression.h" #include "db_common.h" @@ -1210,6 +1211,7 @@ int RelationalSyncAbleStorage::PutCloudSyncDataInner(SQLiteSingleVerRelationalSt handle->SetLocalSchema(localSchema); TrackerTable trackerTable = storageEngine_->GetTrackerSchema().GetTrackerTable(tableName); handle->SetLogicDelete(IsCurrentLogicDelete()); + CloudSyncUtils::InitTempAssetsMap(downloadData); errCode = handle->PutCloudSyncData(tableName, tableSchema, trackerTable, downloadData); handle->SetLogicDelete(false); return errCode; @@ -1238,8 +1240,8 @@ int RelationalSyncAbleStorage::GetCloudTableSchema(const TableName &tableName, T return schemaMgr_.GetCloudTableSchema(tableName, tableSchema); } -int RelationalSyncAbleStorage::FillCloudAssetForDownload(const std::string &tableName, VBucket &asset, - bool isDownloadSuccess) +int RelationalSyncAbleStorage::FillCloudAssetForDownload(const std::string &tableName, const std::string &gid, + AssetTypeMap &asset, bool isDownloadSuccess) { if (storageEngine_ == nullptr) { return -E_INVALID_DB; @@ -1255,7 +1257,7 @@ int RelationalSyncAbleStorage::FillCloudAssetForDownload(const std::string &tabl return errCode; } CloudStorageUtils::TransferSchemaFieldToLower(tableSchema); - errCode = transactionHandle_->FillCloudAssetForDownload(tableSchema, asset, isDownloadSuccess); + errCode = transactionHandle_->FillCloudAssetForDownload(tableSchema, gid, asset, isDownloadSuccess); if (errCode != E_OK) { LOGE("fill cloud asset for download failed.%d", errCode); } diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp index 51c41e19a026fe1734c545c19d933dc9d1fd87e2..ccfaa63c4aa216bd766a9e9efd8de37a3b7e7672 100644 --- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp +++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp @@ -20,6 +20,7 @@ #include "cloud/cloud_db_constant.h" #include "cloud/cloud_storage_utils.h" +#include "cloud/cloud_sync_tag_assets.h" #include "data_transformer.h" #include "db_common.h" #include "log_table_manager_factory.h" @@ -2007,12 +2008,13 @@ int SQLiteSingleVerRelationalStorageExecutor::ExecutePutCloudData(const std::str int errCode = E_OK; for (OpType op : downloadData.opType) { VBucket &vBucket = downloadData.data[index]; + AssetTypeMap &assetTypeMap = downloadData.tempAssets[index]; switch (op) { case OpType::INSERT: - errCode = InsertCloudData(vBucket, tableSchema, trackerTable, GetLocalDataKey(index, downloadData)); + errCode = InsertCloudData(vBucket, assetTypeMap, tableSchema, trackerTable, GetLocalDataKey(index, downloadData)); break; case OpType::UPDATE: - errCode = UpdateCloudData(vBucket, tableSchema); + errCode = UpdateCloudData(vBucket, assetTypeMap, tableSchema); break; case OpType::DELETE: errCode = DeleteCloudData(tableName, vBucket, tableSchema, trackerTable); @@ -2338,8 +2340,8 @@ int SQLiteSingleVerRelationalStorageExecutor::PutCloudSyncData(const std::string return errCode == E_OK ? ret : errCode; } -int SQLiteSingleVerRelationalStorageExecutor::InsertCloudData(VBucket &vBucket, const TableSchema &tableSchema, - const TrackerTable &trackerTable, int64_t dataKey) +int SQLiteSingleVerRelationalStorageExecutor::InsertCloudData(VBucket &vBucket, AssetTypeMap &assetTypeMap, + const TableSchema &tableSchema, const TrackerTable &trackerTable, int64_t dataKey) { int errCode = E_OK; if (dataKey > 0) { @@ -2356,8 +2358,9 @@ int SQLiteSingleVerRelationalStorageExecutor::InsertCloudData(VBucket &vBucket, return errCode; } if (putDataMode_ == PutDataMode::SYNC) { - CloudStorageUtils::PrepareToFillAssetFromVBucket(vBucket, CloudStorageUtils::FillAssetBeforeDownload); + CloudStorageUtils::PrepareToFillAssetFromVBucket(assetTypeMap, CloudStorageUtils::FillAssetBeforeDownload); } + CloudSyncUtils::UpdateVBucketAssets(assetTypeMap, vBucket); errCode = BindValueToUpsertStatement(vBucket, tableSchema.fields, insertStmt); if (errCode != E_OK) { SQLiteUtils::ResetStatement(insertStmt, true, errCode); @@ -2649,11 +2652,13 @@ int SQLiteSingleVerRelationalStorageExecutor::GetUpdateDataTableStatement(const return errCode; } -int SQLiteSingleVerRelationalStorageExecutor::UpdateCloudData(VBucket &vBucket, const TableSchema &tableSchema) +int SQLiteSingleVerRelationalStorageExecutor::UpdateCloudData(VBucket &vBucket, AssetTypeMap &assetTypeMap, + const TableSchema &tableSchema) { if (putDataMode_ == PutDataMode::SYNC) { - CloudStorageUtils::PrepareToFillAssetFromVBucket(vBucket, CloudStorageUtils::FillAssetBeforeDownload); + CloudStorageUtils::PrepareToFillAssetFromVBucket(assetTypeMap, CloudStorageUtils::FillAssetBeforeDownload); } + CloudSyncUtils::UpdateVBucketAssets(assetTypeMap, vBucket); sqlite3_stmt *updateStmt = nullptr; int errCode = GetUpdateDataTableStatement(vBucket, tableSchema, updateStmt); if (errCode != E_OK) { diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h index ad5a15c8a097b02c5a0deff29b4ae8b991297133..3091c29cdf3e5b04d4c0fc25bb4011c2683c493d 100644 --- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h +++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h @@ -124,7 +124,8 @@ public: int PutCloudSyncData(const std::string &tableName, const TableSchema &tableSchema, const TrackerTable &trackerTable, DownloadData &downloadData); - int FillCloudAssetForDownload(const TableSchema &tableSchema, VBucket &vBucket, bool isDownloadSuccess); + int FillCloudAssetForDownload(const TableSchema &tableSchema, const std::string &gid, AssetTypeMap &vBucket, + bool isDownloadSuccess); int DoCleanInner(ClearMode mode, const std::vector &tableNameList, const RelationalSchemaObject &localSchema, std::vector &assets); @@ -270,8 +271,8 @@ private: int GetInfoByStatement(sqlite3_stmt *statement, std::vector &assetFields, const std::map &pkMap, DataInfoWithLog &dataInfoWithLog, VBucket &assetInfo); - int InsertCloudData(VBucket &vBucket, const TableSchema &tableSchema, const TrackerTable &trackerTable, - int64_t dataKey); + int InsertCloudData(VBucket &vBucket, AssetTypeMap &assetTypeMap, const TableSchema &tableSchema, + const TrackerTable &trackerTable, int64_t dataKey); int InsertLogRecord(const TableSchema &tableSchema, const TrackerTable &trackerTable, VBucket &vBucket); @@ -293,7 +294,7 @@ private: int GetUpdateDataTableStatement(const VBucket &vBucket, const TableSchema &tableSchema, sqlite3_stmt *&updateStmt); - int UpdateCloudData(VBucket &vBucket, const TableSchema &tableSchema); + int UpdateCloudData(VBucket &vBucket, AssetTypeMap &assetTypeMap, const TableSchema &tableSchema); int GetUpdateLogRecordStatement(const TableSchema &tableSchema, const VBucket &vBucket, OpType opType, std::vector &updateColName, sqlite3_stmt *&updateLogStmt); diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_extend_executor.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_extend_executor.cpp index d782a8afe8dd63dcf86b6ab1fa4e736cc67732ec..a7bc1703580da1c2cce9bac13192de464e76e747 100644 --- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_extend_executor.cpp +++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_extend_executor.cpp @@ -18,6 +18,7 @@ #include "cloud/asset_operation_utils.h" #include "cloud/cloud_db_constant.h" #include "cloud/cloud_storage_utils.h" +#include "cloud_sync_utils.h" #include "db_common.h" #include "log_table_manager_factory.h" #include "runtime_context.h" @@ -93,37 +94,30 @@ int SQLiteSingleVerRelationalStorageExecutor::GetFillDownloadAssetStatement(cons } int SQLiteSingleVerRelationalStorageExecutor::FillCloudAssetForDownload(const TableSchema &tableSchema, - VBucket &vBucket, bool isDownloadSuccess) + const std::string &cloudGid, AssetTypeMap &assetTypeMap, bool isDownloadSuccess) { - std::string cloudGid; - int errCode = CloudStorageUtils::GetValueFromVBucket(CloudDbConstant::GID_FIELD, vBucket, cloudGid); - if (errCode != E_OK) { - LOGE("Miss gid when fill Asset"); - return errCode; - } std::vector assetsField; - errCode = CloudStorageUtils::GetAssetFieldsFromSchema(tableSchema, vBucket, assetsField); + int errCode = CloudStorageUtils::GetAssetFieldsFromSchema(tableSchema, assetTypeMap, assetsField); if (errCode != E_OK) { LOGE("No assets need to be filled."); return errCode; } - CloudStorageUtils::ChangeAssetsOnVBucketToAsset(vBucket, assetsField); + CloudStorageUtils::ChangeAssetsOnVBucketToAsset(assetTypeMap, assetsField); Bytes hashKey; - (void)CloudStorageUtils::GetValueFromVBucket(HASH_KEY, vBucket, hashKey); VBucket dbAssets; errCode = GetAssetsByGidOrHashKey(tableSchema, cloudGid, hashKey, dbAssets); if (errCode != E_OK && errCode != -E_NOT_FOUND) { return errCode; } - AssetOperationUtils::RecordAssetOpType assetOpType = AssetOperationUtils::CalAssetOperation(vBucket, dbAssets, + AssetOperationUtils::RecordAssetOpType assetOpType = AssetOperationUtils::CalAssetOperation(assetTypeMap, dbAssets, AssetOperationUtils::CloudSyncAction::END_DOWNLOAD); if (isDownloadSuccess) { - CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets, + CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, assetTypeMap, dbAssets, CloudStorageUtils::FillAssetAfterDownload, CloudStorageUtils::FillAssetsAfterDownload); } else { - CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets, + CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, assetTypeMap, dbAssets, CloudStorageUtils::FillAssetAfterDownloadFail, CloudStorageUtils::FillAssetsAfterDownloadFail); } @@ -133,6 +127,8 @@ int SQLiteSingleVerRelationalStorageExecutor::FillCloudAssetForDownload(const Ta return errCode; } errCode = ExecuteFillDownloadAssetStatement(stmt, assetsField.size() + 1, cloudGid); + VBucket vBucket; + CloudSyncUtils::UpdateVBucketAssets(assetTypeMap, vBucket); int ret = CleanDownloadChangedAssets(vBucket, assetOpType); return errCode == E_OK ? ret : errCode; } @@ -277,19 +273,21 @@ int SQLiteSingleVerRelationalStorageExecutor::InitFillUploadAssetStatement(OpTyp if (errCode != E_OK) { return errCode; } + AssetTypeMap tempAssetsMap = data.tempAssets.at(index); + CloudSyncUtils::UpdateAssetIdToTempAsset(vBucket, tempAssetsMap); AssetOperationUtils::CloudSyncAction action = opType == OpType::SET_UPLOADING ? AssetOperationUtils::CloudSyncAction::START_UPLOAD : AssetOperationUtils::CloudSyncAction::END_UPLOAD; - AssetOperationUtils::RecordAssetOpType assetOpType = AssetOperationUtils::CalAssetOperation(vBucket, dbAssets, + AssetOperationUtils::RecordAssetOpType assetOpType = AssetOperationUtils::CalAssetOperation(tempAssetsMap, dbAssets, action); if (action == AssetOperationUtils::CloudSyncAction::START_UPLOAD) { - CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets, + CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, tempAssetsMap, dbAssets, CloudStorageUtils::FillAssetBeforeUpload, CloudStorageUtils::FillAssetsBeforeUpload); } else { if (DBCommon::IsRecordError(data.extend.at(index))) { - CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets, + CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, tempAssetsMap, dbAssets, CloudStorageUtils::FillAssetForUploadFailed, CloudStorageUtils::FillAssetsForUploadFailed); } else { - CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets, + CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, tempAssetsMap, dbAssets, CloudStorageUtils::FillAssetForUpload, CloudStorageUtils::FillAssetsForUpload); } } diff --git a/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp b/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp index d5c20f04aed73d308eb0db9ba81d33517edb5932..110fb489bbef82e4734616f7a63516baea6d7cf9 100644 --- a/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp +++ b/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp @@ -352,7 +352,8 @@ int StorageProxy::NotifyChangedData(const std::string &deviceName, ChangedData & return E_OK; } -int StorageProxy::FillCloudAssetForDownload(const std::string &tableName, VBucket &asset, bool isDownloadSuccess) +int StorageProxy::FillCloudAssetForDownload(const std::string &tableName, const std::string &gid, AssetTypeMap &asset, + bool isDownloadSuccess) { std::shared_lock readLock(storeMutex_); if (store_ == nullptr) { @@ -362,7 +363,7 @@ int StorageProxy::FillCloudAssetForDownload(const std::string &tableName, VBucke LOGE("the write transaction has not started before fill download assets"); return -E_TRANSACT_STATE; } - return store_->FillCloudAssetForDownload(tableName, asset, isDownloadSuccess); + return store_->FillCloudAssetForDownload(tableName, gid, asset, isDownloadSuccess); } int StorageProxy::SetLogTriggerStatus(bool status) diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp index ee9bc0caa93181c88c9be5968c5a66b29ac97ffb..f4701fad500366aa851ce8d2087f93173799fb2c 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp @@ -188,6 +188,22 @@ int CloudDBProxy::Download(const std::string &tableName, const std::string &gid, return GetInnerErrorCode(status); } +int CloudDBProxy::RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix, + const std::map &assets) +{ + std::shared_lock readLock(assetLoaderMutex_); + if (iAssetLoader_ == nullptr) { + LOGE("Asset loader has not been set %d", -E_NOT_SET); + return -E_NOT_SET; + } + DBStatus status = iAssetLoader_->RemoveLocalAssets(tableName, gid, prefix, assets); + if (status != OK) { + LOGE("[CloudDBProxy] remove local asset failed %d", static_cast(status)); + return -E_REMOVE_ASSETS_FAILED; + } + return E_OK; +} + int CloudDBProxy::RemoveLocalAssets(const std::vector &assets) { std::shared_lock readLock(assetLoaderMutex_); diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h index b4eefc1289653c1d34855e4042b249538d6684a0..afe69a895b07f4a3f414f03e5c677dd6f110eb4e 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h @@ -56,8 +56,10 @@ public: int Download(const std::string &tableName, const std::string &gid, const Type &prefix, std::map &assets); - int RemoveLocalAssets(const std::vector &assets); + int RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix, + const std::map &assets); + int RemoveLocalAssets(const std::vector &assets); protected: class CloudActionContext { public: diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp index 03ca8f4563296d8a07736e8771fd3832592d26f1..0506d0ea6f8a39cfa674c474426dee59f9563541 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp @@ -18,7 +18,7 @@ namespace DistributedDB { namespace { -void TagSingleAsset(AssetOpType flag, AssetStatus status, Asset &asset, Assets &res, int &errCode) +void TagSingleAsset(AssetOpType flag, AssetStatus status, TempAsset &asset, TempAssets &res, int &errCode) { uint32_t newStatus = static_cast(status); if (flag == AssetOpType::DELETE && status == AssetStatus::DOWNLOADING && @@ -54,7 +54,7 @@ void TagSingleAsset(AssetOpType flag, AssetStatus status, Asset &asset, Assets & } void TagAssetWithNormalStatus(const bool isNormalStatus, AssetOpType flag, - Asset &asset, Assets &res, int &errCode) + TempAsset &asset, TempAssets &res, int &errCode) { if (isNormalStatus) { TagSingleAsset(flag, AssetStatus::NORMAL, asset, res, errCode); @@ -64,9 +64,9 @@ void TagAssetWithNormalStatus(const bool isNormalStatus, AssetOpType flag, } void TagAssetsWithNormalStatus(const bool isNormalStatus, AssetOpType flag, - Assets &assets, Assets &res, int &errCode) + TempAssets &assets, TempAssets &res, int &errCode) { - for (Asset &asset : assets) { + for (TempAsset &asset : assets) { TagAssetWithNormalStatus(isNormalStatus, flag, asset, res, errCode); if (errCode != E_OK) { break; @@ -75,26 +75,26 @@ void TagAssetsWithNormalStatus(const bool isNormalStatus, AssetOpType flag, } template -bool IsDataContainField(const std::string &assetFieldName, const VBucket &data) +bool IsDataContainField(const std::string &assetFieldName, const AssetTypeMap &data) { auto assetIter = data.find(assetFieldName); if (assetIter == data.end()) { return false; } // When type of Assets is not Nil but a vector which size is 0, we think data is not contain this field. - if (assetIter->second.index() == TYPE_INDEX) { - if (std::get(assetIter->second).empty()) { + if (assetIter->second.index() == ASSET_INDEX) { + if (std::get(assetIter->second).empty()) { return false; } } - if (assetIter->second.index() != TYPE_INDEX) { + if (assetIter->second.index() != ASSET_INDEX) { return false; } return true; } -void TagAssetWithSameHash(const bool isNormalStatus, Asset &beCoveredAsset, Asset &coveredAsset, Assets &res, - int &errCode) +void TagAssetWithSameHash(const bool isNormalStatus, TempAsset &beCoveredAsset, TempAsset &coveredAsset, + TempAssets &res, int &errCode) { TagAssetWithNormalStatus(isNormalStatus, ( AssetOperationUtils::EraseBitMask(beCoveredAsset.status) == AssetStatus::DELETE || @@ -105,38 +105,38 @@ void TagAssetWithSameHash(const bool isNormalStatus, Asset &beCoveredAsset, Asse // AssetOpType and AssetStatus will be tagged, assets to be changed will be returned // use VBucket rather than Type because we need to check whether it is empty -Assets TagAssets(const std::string &assetFieldName, VBucket &coveredData, VBucket &beCoveredData, +TempAssets TagAssets(const std::string &assetFieldName, AssetTypeMap &coveredData, AssetTypeMap &beCoveredData, bool setNormalStatus, int &errCode) { - Assets res = {}; - bool beCoveredHasAssets = IsDataContainField(assetFieldName, beCoveredData); - bool coveredHasAssets = IsDataContainField(assetFieldName, coveredData); + TempAssets res = {}; + bool beCoveredHasAssets = IsDataContainField(assetFieldName, beCoveredData); + bool coveredHasAssets = IsDataContainField(assetFieldName, coveredData); if (!beCoveredHasAssets) { if (coveredHasAssets) { // all the element in assets will be set to INSERT TagAssetsWithNormalStatus(setNormalStatus, - AssetOpType::INSERT, std::get(coveredData[assetFieldName]), res, errCode); + AssetOpType::INSERT, std::get(coveredData[assetFieldName]), res, errCode); } return res; } if (!coveredHasAssets) { // all the element in assets will be set to DELETE TagAssetsWithNormalStatus(setNormalStatus, - AssetOpType::DELETE, std::get(beCoveredData[assetFieldName]), res, errCode); + AssetOpType::DELETE, std::get(beCoveredData[assetFieldName]), res, errCode); coveredData[assetFieldName] = res; return res; } - Assets &covered = std::get(coveredData[assetFieldName]); - Assets &beCovered = std::get(beCoveredData[assetFieldName]); + TempAssets &covered = std::get(coveredData[assetFieldName]); + TempAssets &beCovered = std::get(beCoveredData[assetFieldName]); std::map coveredAssetsIndexMap = CloudStorageUtils::GenAssetsIndexMap(covered); - for (Asset &beCoveredAsset : beCovered) { + for (TempAsset &beCoveredAsset : beCovered) { auto it = coveredAssetsIndexMap.find(beCoveredAsset.name); if (it == coveredAssetsIndexMap.end()) { TagAssetWithNormalStatus(setNormalStatus, AssetOpType::DELETE, beCoveredAsset, res, errCode); - std::get(coveredData[assetFieldName]).push_back(beCoveredAsset); + std::get(coveredData[assetFieldName]).push_back(beCoveredAsset); continue; } - Asset &coveredAsset = covered[it->second]; + TempAsset &coveredAsset = covered[it->second]; if (beCoveredAsset.hash != coveredAsset.hash) { TagAssetWithNormalStatus(setNormalStatus, AssetOpType::UPDATE, coveredAsset, res, errCode); } else { @@ -161,40 +161,40 @@ Assets TagAssets(const std::string &assetFieldName, VBucket &coveredData, VBucke } // AssetOpType and AssetStatus will be tagged, assets to be changed will be returned -Assets TagAsset(const std::string &assetFieldName, VBucket &coveredData, VBucket &beCoveredData, +TempAssets TagAsset(const std::string &assetFieldName, AssetTypeMap &coveredData, AssetTypeMap &beCoveredData, bool setNormalStatus, int &errCode) { - Assets res = {}; - bool beCoveredHasAsset = IsDataContainField(assetFieldName, beCoveredData) || - IsDataContainField(assetFieldName, beCoveredData); - bool coveredHasAsset = IsDataContainField(assetFieldName, coveredData); + TempAssets res = {}; + bool beCoveredHasAsset = IsDataContainField(assetFieldName, beCoveredData) || + IsDataContainField(assetFieldName, beCoveredData); + bool coveredHasAsset = IsDataContainField(assetFieldName, coveredData); if (!beCoveredHasAsset) { if (!coveredHasAsset) { LOGD("[CloudSyncer] Both data do not contain certain asset field"); return res; } TagAssetWithNormalStatus(setNormalStatus, AssetOpType::INSERT, - std::get(coveredData[assetFieldName]), res, errCode); + std::get(coveredData[assetFieldName]), res, errCode); return res; } if (!coveredHasAsset) { - if (beCoveredData[assetFieldName].index() == TYPE_INDEX) { + if (beCoveredData[assetFieldName].index() == ASSET_INDEX) { TagAssetWithNormalStatus(setNormalStatus, AssetOpType::DELETE, - std::get(beCoveredData[assetFieldName]), res, errCode); - } else if (beCoveredData[assetFieldName].index() == TYPE_INDEX) { + std::get(beCoveredData[assetFieldName]), res, errCode); + } else if (beCoveredData[assetFieldName].index() == ASSET_INDEX) { TagAssetsWithNormalStatus(setNormalStatus, AssetOpType::DELETE, - std::get(beCoveredData[assetFieldName]), res, errCode); + std::get(beCoveredData[assetFieldName]), res, errCode); } return res; } - Asset &covered = std::get(coveredData[assetFieldName]); - Asset beCovered; - if (beCoveredData[assetFieldName].index() == TYPE_INDEX) { + TempAsset &covered = std::get(coveredData[assetFieldName]); + TempAsset beCovered; + if (beCoveredData[assetFieldName].index() == ASSET_INDEX) { // This indicates that asset in cloudData is stored as Asset - beCovered = std::get(beCoveredData[assetFieldName]); - } else if (beCoveredData[assetFieldName].index() == TYPE_INDEX) { + beCovered = std::get(beCoveredData[assetFieldName]); + } else if (beCoveredData[assetFieldName].index() == ASSET_INDEX) { // Stored as ASSETS, first element in assets will be the target asset - beCovered = (std::get(beCoveredData[assetFieldName]))[0]; + beCovered = (std::get(beCoveredData[assetFieldName]))[0]; } else { LOGE("The type of data is neither Asset nor Assets"); return res; @@ -207,18 +207,18 @@ Assets TagAsset(const std::string &assetFieldName, VBucket &coveredData, VBucket if (covered.hash != beCovered.hash) { TagAssetWithNormalStatus(setNormalStatus, AssetOpType::UPDATE, covered, res, errCode); } else { - Assets tmpAssets = {}; + TempAssets tmpAssets = {}; TagAssetWithNormalStatus(true, AssetOpType::NO_CHANGE, covered, tmpAssets, errCode); } return res; } } // namespace -Assets TagAssetsInSingleCol( - VBucket &coveredData, VBucket &beCoveredData, const Field &assetField, bool setNormalStatus, int &errCode) +TempAssets TagAssetsInSingleCol( + AssetTypeMap &coveredData, AssetTypeMap &beCoveredData, const Field &assetField, bool setNormalStatus, int &errCode) { // Define a list to store the tagged result - Assets assets = {}; + TempAssets assets = {}; switch (assetField.type) { case TYPE_INDEX: { assets = TagAssets(assetField.colName, coveredData, beCoveredData, setNormalStatus, errCode); diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h index 767800564ed7b0cf9791b08bf7f07659642e6ec8..2fe772f346326c65dceb60bec438d525e85be02e 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h @@ -28,7 +28,7 @@ namespace DistributedDB { -Assets TagAssetsInSingleCol( - VBucket &coveredData, VBucket &beCoveredData, const Field &assetField, bool setNormalStatus, int &errCode); +TempAssets TagAssetsInSingleCol(AssetTypeMap &coveredData, AssetTypeMap &beCoveredData, const Field &assetField, + bool setNormalStatus, int &errCode); } // namespace DistributedDB #endif // CLOUD_SYNC_TAG_ASSETS_H \ No newline at end of file diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp index b5ca1fbc625c2676e4b83e71428946b6f319b7c5..9727875ff5a6ebed0c78a089a7087f55a7f72fae 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp @@ -14,6 +14,7 @@ */ #include "cloud/asset_operation_utils.h" #include "cloud/cloud_db_constant.h" +#include "cloud/cloud_storage_utils.h" #include "db_common.h" #include "db_errno.h" #include "log_print.h" @@ -100,26 +101,26 @@ AssetOpType CloudSyncUtils::StatusToFlag(AssetStatus status) } } -void CloudSyncUtils::StatusToFlagForAsset(Asset &asset) +void CloudSyncUtils::StatusToFlagForAsset(TempAsset &asset) { asset.flag = static_cast(StatusToFlag(static_cast(asset.status))); asset.status = static_cast(AssetStatus::NORMAL); } -void CloudSyncUtils::StatusToFlagForAssets(Assets &assets) +void CloudSyncUtils::StatusToFlagForAssets(TempAssets &assets) { - for (Asset &asset : assets) { + for (TempAsset &asset : assets) { StatusToFlagForAsset(asset); } } -void CloudSyncUtils::StatusToFlagForAssetsInRecord(const std::vector &fields, VBucket &record) +void CloudSyncUtils::StatusToFlagForAssetsInRecord(const std::vector &fields, AssetTypeMap &record) { for (const Field &field : fields) { - if (field.type == TYPE_INDEX && record[field.colName].index() == TYPE_INDEX) { - StatusToFlagForAssets(std::get(record[field.colName])); - } else if (field.type == TYPE_INDEX && record[field.colName].index() == TYPE_INDEX) { - StatusToFlagForAsset(std::get(record[field.colName])); + if (field.type == ASSET_INDEX && record[field.colName].index() == ASSET_INDEX) { + StatusToFlagForAssets(std::get(record[field.colName])); + } else if (field.type == ASSET_INDEX && record[field.colName].index() == ASSET_INDEX) { + StatusToFlagForAsset(std::get(record[field.colName])); } } } @@ -503,7 +504,7 @@ int CloudSyncUtils::FillAssetIdToAssetsData(const Assets &extend, Assets &assets { int errCode = E_OK; for (auto &asset : assets) { - if (asset.flag != static_cast(AssetOpType::INSERT)) { + if (asset.status != static_cast(AssetStatus::INSERT)) { continue; } auto extendAssets = extend; @@ -526,13 +527,13 @@ int CloudSyncUtils::FillAssetIdToAssetsData(const Assets &extend, Assets &assets bool CloudSyncUtils::CheckIfContainsInsertAssets(const Type &assetData) { if (assetData.index() == TYPE_INDEX) { - if (std::get(assetData).flag != static_cast(AssetOpType::INSERT)) { + if (std::get(assetData).status != static_cast(AssetStatus::INSERT)) { return false; } } else if (assetData.index() == TYPE_INDEX) { bool hasInsertAsset = false; for (const auto &asset : std::get(assetData)) { - if (asset.flag == static_cast(AssetOpType::INSERT)) { + if (asset.status == static_cast(AssetStatus::INSERT)) { hasInsertAsset = true; break; } @@ -544,10 +545,255 @@ bool CloudSyncUtils::CheckIfContainsInsertAssets(const Type &assetData) return true; } -void CloudSyncUtils::UpdateAssetsFlag(CloudSyncData &uploadData) +void CloudSyncUtils::UpdateAssetsStatus(CloudSyncData &uploadData) { - AssetOperationUtils::UpdateAssetsFlag(uploadData.insData.record, uploadData.insData.assets); - AssetOperationUtils::UpdateAssetsFlag(uploadData.updData.record, uploadData.updData.assets); - AssetOperationUtils::UpdateAssetsFlag(uploadData.delData.record, uploadData.delData.assets); + AssetOperationUtils::UpdateAssetsStatus(uploadData.insData.record, uploadData.insData.assets); + AssetOperationUtils::UpdateAssetsStatus(uploadData.updData.record, uploadData.updData.assets); + AssetOperationUtils::UpdateAssetsStatus(uploadData.delData.record, uploadData.delData.assets); +} + +void CloudSyncUtils::CopyAssetsToTempAssets(const Assets &assets, TempAssets &tempAssets) +{ + tempAssets.clear(); + for (const auto &asset : assets) { + TempAsset tempAsset; + CopyAssetToTempAsset(asset, tempAsset); + tempAssets.push_back(tempAsset); + } +} + +void CloudSyncUtils::CopyAssetToTempAsset(const Asset &asset, TempAsset &tempAsset) +{ + tempAsset.version = asset.version; + tempAsset.name = asset.name; + tempAsset.assetId = asset.assetId; + tempAsset.subpath = asset.subpath; + tempAsset.uri = asset.uri; + tempAsset.modifyTime = asset.modifyTime; + tempAsset.createTime = asset.createTime; + tempAsset.size = asset.size; + tempAsset.hash = asset.hash; + tempAsset.status = asset.status; + tempAsset.timestamp = asset.timestamp; +} + +void CloudSyncUtils::CopyTempAssetsToAssets(const TempAssets &tempAssets, Assets &assets) +{ + assets.clear(); + for (const auto &tempAsset : tempAssets) { + Asset asset; + CopyTempAssetToAsset(tempAsset, asset); + assets.push_back(asset); + } +} + +void CloudSyncUtils::CopyTempAssetToAsset(const TempAsset &tempAsset, Asset &asset) +{ + asset.version = tempAsset.version; + asset.name = tempAsset.name; + asset.assetId = tempAsset.assetId; + asset.subpath = tempAsset.subpath; + asset.uri = tempAsset.uri; + asset.modifyTime = tempAsset.modifyTime; + asset.createTime = tempAsset.createTime; + asset.size = tempAsset.size; + asset.hash = tempAsset.hash; + asset.status = tempAsset.status; + asset.timestamp = tempAsset.timestamp; +} + +void CloudSyncUtils::InitTempAssetsMap(CloudSyncBatch &uploadData) +{ + uploadData.tempAssets.resize(uploadData.assets.size()); + size_t index = 0; + for (const auto &data : uploadData.assets) { + for (const auto &item : data) { + if (item.second.index() == TYPE_INDEX) { + TempAsset tempAsset; + CopyAssetToTempAsset(std::get(item.second), tempAsset); + uploadData.tempAssets[index][item.first] = tempAsset; + } else if (item.second.index() == TYPE_INDEX) { + TempAssets tempAssets; + CopyAssetsToTempAssets(std::get(item.second), tempAssets); + uploadData.tempAssets[index][item.first] = tempAssets; + } + } + index++; + } +} + +void CloudSyncUtils::InitTempAssetsMap(CloudSyncData &uploadData) +{ + InitTempAssetsMap(uploadData.insData); + InitTempAssetsMap(uploadData.updData); + InitTempAssetsMap(uploadData.delData); +} + +void CloudSyncUtils::AssignUploadAssets(CloudSyncBatch &uploadData) +{ + size_t index = 0; + for (const auto &data : uploadData.tempAssets) { + for (const auto &item : data) { + if (item.second.index() == ASSET_INDEX) { + Asset asset; + CopyTempAssetToAsset(std::get(item.second), asset); + if (asset.status != static_cast(AssetStatus::ABNORMAL)) { + asset.status = static_cast(CloudStorageUtils::FlagToStatus(static_cast(std::get(item.second).flag))); + } + uploadData.record[index][item.first] = asset; + } else if (item.second.index() == ASSET_INDEX) { + Assets assets; + CopyTempAssetsToAssets(std::get(item.second), assets); + size_t i = 0; + for (auto &asset : assets) { + if (asset.status != static_cast(AssetStatus::ABNORMAL)) { + asset.status = static_cast(CloudStorageUtils::FlagToStatus(static_cast(std::get(item.second)[i].flag))); + } + i++; + } + uploadData.record[index][item.first] = assets; + } + } + index++; + } +} + +void CloudSyncUtils::AssignUploadAssets(CloudSyncData &uploadData) +{ + AssignUploadAssets(uploadData.insData); + AssignUploadAssets(uploadData.updData); + AssignUploadAssets(uploadData.delData); +} + +void CloudSyncUtils::InitTempAssetsMap(DownloadData &downloadData) +{ + downloadData.tempAssets.resize(downloadData.data.size()); + size_t index = 0; + for (const auto &data : downloadData.data) { + for (const auto &item : data) { + if (item.second.index() == TYPE_INDEX) { + TempAsset tempAsset; + CopyAssetToTempAsset(std::get(item.second), tempAsset); + downloadData.tempAssets[index][item.first] = tempAsset; + } else if (item.second.index() == TYPE_INDEX) { + TempAssets tempAssets; + CopyAssetsToTempAssets(std::get(item.second), tempAssets); + downloadData.tempAssets[index][item.first] = tempAssets; + } + } + index++; + } +} + +void CloudSyncUtils::InitTempAssetsMap(const VBucket &data, AssetTypeMap &tempAssetsMap) +{ + for (const auto &item : data) { + if (item.second.index() == TYPE_INDEX) { + TempAsset tempAsset; + CopyAssetToTempAsset(std::get(item.second), tempAsset); + tempAssetsMap[item.first] = tempAsset; + } else if (item.second.index() == TYPE_INDEX) { + TempAssets tempAssets; + CopyAssetsToTempAssets(std::get(item.second), tempAssets); + tempAssetsMap[item.first] = tempAssets; + } + } +} + +void CloudSyncUtils::UpdateVBucketAssets(const AssetTypeMap &tempAssetsMap, VBucket &data) +{ + for (const auto &item : tempAssetsMap) { + if (item.second.index() == ASSET_INDEX) { + Asset asset; + CopyTempAssetToAsset(std::get(item.second), asset); + data[item.first] = asset; + } else if (item.second.index() == ASSET_INDEX) { + Assets assets; + CopyTempAssetsToAssets(std::get(item.second), assets); + data[item.first] = assets; + } + } +} + +void CloudSyncUtils::AssignDownloadAssets(DownloadData &downloadData) +{ + size_t index = 0; + for (const auto &data : downloadData.tempAssets) { + for (const auto &item : data) { + if (item.second.index() == ASSET_INDEX) { + Asset asset; + CopyTempAssetToAsset(std::get(item.second), asset); + downloadData.data[index][item.first] = asset; + } else if (item.second.index() == ASSET_INDEX) { + Assets assets; + CopyTempAssetsToAssets(std::get(item.second), assets); + downloadData.data[index][item.first] = assets; + } + } + index++; + } + +} +void CloudSyncUtils::InitDownloadAndRemoveAssets(std::map &assets, + std::map &removeAssetsMap, std::map &downloadAssetsMap) +{ + for (const auto &item : assets) { + Assets removeAssets; + Assets downloadAssets; + for (const auto &tempAsset : item.second) { + Asset asset; + if (tempAsset.flag == static_cast(AssetOpType::DELETE)) { + CopyTempAssetToAsset(tempAsset, asset); + asset.status = static_cast(AssetStatus::DELETE); + removeAssets.push_back(asset); + } else { + CopyTempAssetToAsset(tempAsset, asset); + downloadAssets.push_back(asset); + } + + } + removeAssetsMap[item.first] = removeAssets; + downloadAssetsMap[item.first] = downloadAssets; + } +} + +// void CloudSyncUtils::SetStatus(std::vector &assets) +// { +// for (auto &assetMap : assets) { +// SetStatusInner(assetMap); +// } +// } + +// void CloudSyncUtils::SetStatusInner(VBucket &assetMap) +// { +// for (auto &item : assetMap) { +// if (item.second.index() == TYPE_INDEX) { +// std::get(item.second).status = static_cast(AssetStatus::NORMAL); +// } else if (item.second.index() == TYPE_INDEX) { +// for (auto &asset : std::get(item.second)) { +// asset.status = static_cast(AssetStatus::NORMAL); +// } +// } +// } +// } + +void CloudSyncUtils::UpdateAssetIdToTempAsset(const VBucket &assets, AssetTypeMap &assetTypeMap) +{ + for (const auto &item : assets) { + if (item.second.index() == TYPE_INDEX) { + std::get(assetTypeMap[item.first]).assetId = std::get(item.second).assetId; + std::get(assetTypeMap[item.first]).status = std::get(item.second).status; + std::get(assetTypeMap[item.first]).timestamp = std::get(item.second).timestamp; + } else if (item.second.index() == TYPE_INDEX) { + for (uint32_t index = 0; index < std::get(item.second).size(); index++) { + std::get(assetTypeMap[item.first]).at(index).assetId = + std::get(item.second).at(index).assetId; + std::get(assetTypeMap[item.first]).at(index).status = + std::get(item.second).at(index).status; + std::get(assetTypeMap[item.first]).at(index).timestamp = + std::get(item.second).at(index).timestamp; + } + } + } } } \ No newline at end of file diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h index 6b1260f8991d6a25161337fa1a7eab576d83aecf..0a12cbdaee81b897772b5ca50c0eb8680c1cb005 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h @@ -42,11 +42,11 @@ public: static AssetOpType StatusToFlag(AssetStatus status); - static void StatusToFlagForAsset(Asset &asset); + static void StatusToFlagForAsset(TempAsset &asset); - static void StatusToFlagForAssets(Assets &assets); + static void StatusToFlagForAssets(TempAssets &assets); - static void StatusToFlagForAssetsInRecord(const std::vector &fields, VBucket &record); + static void StatusToFlagForAssetsInRecord(const std::vector &fields, AssetTypeMap &record); static bool IsChangeDataEmpty(const ChangedData &changedData); @@ -94,7 +94,36 @@ public: static bool CheckIfContainsInsertAssets(const Type &assetData); - static void UpdateAssetsFlag(CloudSyncData &uploadData); + static void UpdateAssetsStatus(CloudSyncData &uploadData); + + static void CopyAssetsToTempAssets(const Assets &assets, TempAssets &tempAssets); + + static void CopyAssetToTempAsset(const Asset &asset, TempAsset &tempAsset); + + static void CopyTempAssetsToAssets(const TempAssets &tempAssets, Assets &assets); + + static void CopyTempAssetToAsset(const TempAsset &tempAsset, Asset &asset); + + static void InitTempAssetsMap(CloudSyncBatch &uploadData); + + static void InitTempAssetsMap(CloudSyncData &uploadData); + + static void AssignUploadAssets(CloudSyncBatch &uploadData); + + static void AssignUploadAssets(CloudSyncData &uploadData); + + static void InitTempAssetsMap(DownloadData &downloadData); + + static void InitTempAssetsMap(const VBucket &data, AssetTypeMap &tempAssetsMap); + + static void UpdateVBucketAssets(const AssetTypeMap &tempAssetsMap, VBucket &data); + + static void AssignDownloadAssets(DownloadData &downloadData); + + static void InitDownloadAndRemoveAssets(std::map &assets, + std::map &removeAssetsMap, std::map &downloadAssetsMap); + + static void UpdateAssetIdToTempAsset(const VBucket &assets, AssetTypeMap &assetTypeMap); }; } #endif // CLOUD_SYNC_UTILS_H \ No newline at end of file diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp index 4bb8402106cd9dde0b0c139fa830ad9e724dcd45..9e1273e495a8efaa9a663cb8b9ae7f9b3d8223c4 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp @@ -422,11 +422,11 @@ void CloudSyncer::WaitAllSyncCallbackTaskFinish() LOGD("[CloudSyncer] End wait all callback task finish"); } -std::map CloudSyncer::TagAssetsInSingleRecord(VBucket &coveredData, VBucket &beCoveredData, - bool setNormalStatus, int &errCode) +std::map CloudSyncer::TagAssetsInSingleRecord(AssetTypeMap &coveredData, + AssetTypeMap &beCoveredData, bool setNormalStatus, int &errCode) { // Define a map to store the result - std::map res = {}; + std::map res = {}; std::vector assetFields; { std::lock_guard autoLock(dataLock_); @@ -434,7 +434,7 @@ std::map CloudSyncer::TagAssetsInSingleRecord(VBucket &cove } // For every column contain asset or assets, assetFields are in context for (const Field &assetField : assetFields) { - Assets assets = TagAssetsInSingleCol(coveredData, beCoveredData, assetField, setNormalStatus, errCode); + TempAssets assets = TagAssetsInSingleCol(coveredData, beCoveredData, assetField, setNormalStatus, errCode); if (!assets.empty()) { res[assetField.colName] = assets; } @@ -445,19 +445,19 @@ std::map CloudSyncer::TagAssetsInSingleRecord(VBucket &cove return res; } -int CloudSyncer::FillCloudAssets(const std::string &tableName, VBucket &normalAssets, - VBucket &failedAssets) +int CloudSyncer::FillCloudAssets(const std::string &tableName, AssetTypeMap &normalAssets, + AssetTypeMap &failedAssets, const std::string &gid) { int ret = E_OK; - if (normalAssets.size() > 1) { - ret = storageProxy_->FillCloudAssetForDownload(tableName, normalAssets, true); + if (normalAssets.size() > 0) { + ret = storageProxy_->FillCloudAssetForDownload(tableName, gid, normalAssets, true); if (ret != E_OK) { LOGE("[CloudSyncer] Can not fill normal cloud assets for download"); return ret; } } - if (failedAssets.size() > 1) { - ret = storageProxy_->FillCloudAssetForDownload(tableName, failedAssets, false); + if (failedAssets.size() > 0) { + ret = storageProxy_->FillCloudAssetForDownload(tableName, gid, failedAssets, false); if (ret != E_OK) { LOGE("[CloudSyncer] Can not fill abnormal assets for download"); return ret; @@ -665,8 +665,10 @@ int CloudSyncer::HandleTagAssets(const Key &hashKey, const DataInfo &dataInfo, s return -E_INTERNAL_ERROR; } AssetOperationUtils::FilterDeleteAsset(param.downloadData.data[idx]); - std::map assetsMap = TagAssetsInSingleRecord(param.downloadData.data[idx], localAssetInfo, - false, ret); + AssetTypeMap tempLocalAssetInfo; + CloudSyncUtils::InitTempAssetsMap(localAssetInfo, tempLocalAssetInfo); + std::map assetsMap = TagAssetsInSingleRecord(param.downloadData.tempAssets[idx], + tempLocalAssetInfo, false, ret); if (ret != E_OK) { LOGE("[CloudSyncer] TagAssetsInSingleRecord report ERROR in download data"); return ret; @@ -763,6 +765,7 @@ int CloudSyncer::SaveData(SyncParam ¶m) return ret; } } + CloudSyncUtils::AssignDownloadAssets(param.downloadData); // Save assetsMap into current context { std::lock_guard autoLock(dataLock_); @@ -1193,8 +1196,8 @@ int CloudSyncer::TagUploadAssets(CloudSyncData &uploadData) // for delete scenario, assets should not appear in the records. Thereby we needn't tag the assests. // for insert scenario, gid does not exist. Thereby, we needn't compare with cloud asset get in download procedure for (size_t i = 0; i < uploadData.insData.extend.size(); i++) { - VBucket cloudAsset; // cloudAsset must be empty - (void)TagAssetsInSingleRecord(uploadData.insData.record[i], cloudAsset, true, errCode); + AssetTypeMap cloudAsset; // cloudAsset must be empty + (void)TagAssetsInSingleRecord(uploadData.insData.tempAssets[i], cloudAsset, true, errCode); if (errCode != E_OK) { LOGE("[CloudSyncer] TagAssetsInSingleRecord report ERROR in DELETE/INSERT option"); return errCode; @@ -1202,7 +1205,7 @@ int CloudSyncer::TagUploadAssets(CloudSyncData &uploadData) } // for update scenario, assets shoulb be compared with asset get in download procedure. for (size_t i = 0; i < uploadData.updData.extend.size(); i++) { - VBucket cloudAsset; + AssetTypeMap cloudAsset; // gid must exist in UPDATE scenario, cause we have re-fill gid during download procedure // But we need to check for safety auto gidIter = uploadData.updData.extend[i].find(CloudDbConstant::GID_FIELD); @@ -1220,13 +1223,15 @@ int CloudSyncer::TagUploadAssets(CloudSyncData &uploadData) std::lock_guard autoLock(dataLock_); assetFields = currentContext_.assetFields[currentContext_.tableName]; } - CloudSyncUtils::StatusToFlagForAssetsInRecord(assetFields, uploadData.updData.record[i]); + CloudSyncUtils::StatusToFlagForAssetsInRecord(assetFields, uploadData.updData.tempAssets[i]); continue; } for (const auto &it : cloudAssets[gid]) { - cloudAsset[it.first] = it.second; + TempAssets tempAssets; + CloudSyncUtils::CopyAssetsToTempAssets(it.second, tempAssets); + cloudAsset[it.first] = tempAssets; } - (void)TagAssetsInSingleRecord(uploadData.updData.record[i], cloudAsset, true, errCode); + (void)TagAssetsInSingleRecord(uploadData.updData.tempAssets[i], cloudAsset, true, errCode); if (errCode != E_OK) { LOGE("[CloudSyncer] TagAssetsInSingleRecord report ERROR in UPDATE option"); return errCode; @@ -1254,7 +1259,8 @@ int CloudSyncer::PreProcessBatchUpload(TaskId taskId, const InnerProcessInfo &in LOGE("TagUploadAssets report ERROR, cannot tag uploadAssets"); return ret; } - CloudSyncUtils::UpdateAssetsFlag(uploadData); + CloudSyncUtils::AssignUploadAssets(uploadData); + // CloudSyncUtils::UpdateAssetsStatus(uploadData); // get local water mark to be updated in future. ret = CloudSyncUtils::UpdateExtendTime(uploadData, innerProcessInfo.upLoadInfo.total, taskId, localMark); if (ret != E_OK) { @@ -1316,6 +1322,7 @@ int CloudSyncer::DoUploadInner(const std::string &tableName, UploadParam &upload LOGE("[CloudSyncer] Failed to get cloud data when upload, %d.", ret); return ret; } + CloudSyncUtils::InitTempAssetsMap(uploadData); uploadParam.count -= uploadData.ignoredCount; InnerProcessInfo info = GetInnerProcessInfo(tableName, uploadParam); @@ -1348,6 +1355,8 @@ int CloudSyncer::DoUploadInner(const std::string &tableName, UploadParam &upload break; } ChkIgnoredProcess(info, uploadData, uploadParam); + info.upLoadInfo.total -= static_cast(uploadData.ignoredCount); + CloudSyncUtils::InitTempAssetsMap(uploadData); } if (ret != -E_TASK_PAUSED) { // reset watermark to zero when task no paused @@ -2059,6 +2068,7 @@ int CloudSyncer::DownloadDataFromCloud(TaskId taskId, SyncParam ¶m, bool &ab NotifyInEmptyDownload(taskId, param.info); abort = true; } + CloudSyncUtils::InitTempAssetsMap(param.downloadData); return E_OK; } diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h index 64e33176ef87e12724ec43225dd58b280d08d5c3..c839a6ef4274c06686689b937fa1f1ebcfedda9e 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h @@ -35,7 +35,7 @@ #include "store_observer.h" namespace DistributedDB { -using DownloadCommitList = std::vector, bool>>; +using DownloadCommitList = std::vector, bool>>; class CloudSyncer : public ICloudSyncer { public: explicit CloudSyncer(std::shared_ptr storageProxy); @@ -89,7 +89,7 @@ protected: std::string gid; Type prefix; OpType strategy; - std::map assets; + std::map assets; Key hashKey; std::vector primaryKeyValList; bool recordConflict = false; @@ -203,7 +203,7 @@ protected: std::map GetAssetsFromVBucket(VBucket &data); - std::map TagAssetsInSingleRecord(VBucket &coveredData, VBucket &beCoveredData, + std::map TagAssetsInSingleRecord(AssetTypeMap &coveredData, AssetTypeMap &beCoveredData, bool setNormalStatus, int &errCode); int TagStatus(bool isExist, SyncParam ¶m, size_t idx, DataInfo &dataInfo, VBucket &localAssetInfo); @@ -216,8 +216,8 @@ protected: int TagUploadAssets(CloudSyncData &uploadData); - int FillCloudAssets(const std::string &tableName, VBucket &normalAssets, - VBucket &failedAssets); + int FillCloudAssets(const std::string &tableName, AssetTypeMap &normalAssets, + AssetTypeMap &failedAssets, const std::string &gid); int HandleDownloadResult(bool recordConflict, const std::string &tableName, DownloadCommitList &commitList, uint32_t &successCount); @@ -308,13 +308,13 @@ protected: int BatchUpdate(Info &updateInfo, CloudSyncData &uploadData, InnerProcessInfo &innerProcessInfo); int DownloadAssetsOneByOne(const InnerProcessInfo &info, DownloadItem &downloadItem, - std::map &downloadAssets); + std::map &downloadAssets); int GetDBAssets(bool isSharedTable, const InnerProcessInfo &info, const DownloadItem &downloadItem, VBucket &dbAssets); int DownloadAssetsOneByOneInner(bool isSharedTable, const InnerProcessInfo &info, DownloadItem &downloadItem, - std::map &downloadAssets); + std::map &downloadAssets); int CommitDownloadAssets(bool recordConflict, const std::string &tableName, DownloadCommitList &commitList, uint32_t &successCount); diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp index 7d8d654aacfed0f158003a28d7901449361ca037..7da976ef0e6d7613fe7cd5b21a9b5838928bc0c1 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp +++ b/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp @@ -199,7 +199,7 @@ int CloudSyncer::BatchUpdate(Info &updateInfo, CloudSyncData &uploadData, InnerP } int CloudSyncer::DownloadAssetsOneByOne(const InnerProcessInfo &info, DownloadItem &downloadItem, - std::map &downloadAssets) + std::map &downloadAssets) { bool isSharedTable = false; int errCode = storageProxy_->IsSharedTable(info.tableName, isSharedTable); @@ -253,13 +253,13 @@ int CloudSyncer::GetDBAssets(bool isSharedTable, const InnerProcessInfo &info, c } int CloudSyncer::DownloadAssetsOneByOneInner(bool isSharedTable, const InnerProcessInfo &info, - DownloadItem &downloadItem, std::map &downloadAssets) + DownloadItem &downloadItem, std::map &downloadAssets) { int errCode = E_OK; for (auto &[col, assets] : downloadAssets) { - Assets callDownloadAssets; + TempAssets callDownloadAssets; for (auto &asset : assets) { - std::map tmpAssets; + std::map tmpAssets; tmpAssets[col] = { asset }; uint32_t tmpFlag = asset.flag; VBucket dbAssets; @@ -270,7 +270,18 @@ int CloudSyncer::DownloadAssetsOneByOneInner(bool isSharedTable, const InnerProc } if (!isSharedTable && AssetOperationUtils::CalAssetOperation(col, asset, dbAssets, AssetOperationUtils::CloudSyncAction::START_DOWNLOAD) == AssetOperationUtils::AssetOpType::HANDLE) { - tmpCode = cloudDB_.Download(info.tableName, downloadItem.gid, downloadItem.prefix, tmpAssets); + std::map removeAssetsMap; + std::map downloadAssetsMap; + CloudSyncUtils::InitDownloadAndRemoveAssets(tmpAssets, removeAssetsMap, downloadAssetsMap); + if (!downloadAssetsMap[col].empty()) { + tmpCode = cloudDB_.Download(info.tableName, downloadItem.gid, downloadItem.prefix, + downloadAssetsMap); + tmpAssets[col][0].status = downloadAssetsMap[col][0].status; + } else if (!removeAssetsMap[col].empty()) { + tmpCode = cloudDB_.Download(info.tableName, downloadItem.gid, downloadItem.prefix, + removeAssetsMap); + tmpAssets[col][0].status = removeAssetsMap[col][0].status; + } } else { LOGD("[CloudSyncer] skip download asset..."); continue; @@ -305,17 +316,15 @@ int CloudSyncer::CommitDownloadAssets(bool recordConflict, const std::string &ta for (auto &item : commitList) { std::string gid = std::get<0>(item); // 0 means gid is the first element in assetsInfo // 1 means assetsMap info [colName, assets] is the forth element in downloadList[i] - std::map assetsMap = std::get<1>(item); + std::map assetsMap = std::get<1>(item); bool setAllNormal = std::get<2>(item); // 2 means whether the download return is E_OK - VBucket normalAssets; - VBucket failedAssets; - normalAssets[CloudDbConstant::GID_FIELD] = gid; - failedAssets[CloudDbConstant::GID_FIELD] = gid; - VBucket &assets = setAllNormal ? normalAssets : failedAssets; - for (auto &[key, asset] : assetsMap) { - assets[key] = std::move(asset); + AssetTypeMap normalAssets; + AssetTypeMap failedAssets; + AssetTypeMap &assets = setAllNormal ? normalAssets : failedAssets; + for (auto &[key, tempAssets] : assetsMap) { + assets[key] = tempAssets; } - errCode = FillCloudAssets(tableName, normalAssets, failedAssets); + errCode = FillCloudAssets(tableName, normalAssets, failedAssets, gid); if (errCode != E_OK) { return errCode; } diff --git a/frameworks/libs/distributeddb/syncer/src/cloud/icloud_syncer.h b/frameworks/libs/distributeddb/syncer/src/cloud/icloud_syncer.h index 577f4461b35258f507106b0c57938281ba8d79cd..88040e557f2a3a0ad7d079ad1ad9879c0a9bf7d5 100644 --- a/frameworks/libs/distributeddb/syncer/src/cloud/icloud_syncer.h +++ b/frameworks/libs/distributeddb/syncer/src/cloud/icloud_syncer.h @@ -21,7 +21,7 @@ #include "query_sync_object.h" #include "ref_object.h" namespace DistributedDB { -using DownloadList = std::vector, Key, +using DownloadList = std::vector, Key, std::vector>>; class ICloudSyncer : public virtual RefObject { public: diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp index a3cf2b8ce949512dc8ab304c91f5c440aecabdd6..dd1073d265915958f8f911afc376c7d913c9cc09 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp @@ -286,7 +286,7 @@ void DistributedDBCloudAssetsOperationSyncTest::ForkDownloadAndRemoveAsset(DBSta } }); virtualAssetLoader_->ForkRemoveLocalAssets([removeStatus, &removeCount](const std::vector &assets) { - EXPECT_EQ(assets.size(), 2u); // one record has 2 asset + EXPECT_EQ(assets.size(), 2u); // onew record has 2 asset removeCount++; return removeStatus; }); diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp index 1dbc15ddab079ed68aa1e5b2967e76eecc967313..33f022cbf532a8f702e92630012ddb99c926e2fe 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp @@ -407,7 +407,8 @@ namespace { std::vector names = { g_cloudAsset.name + std::to_string(0), g_cloudAsset.name + std::to_string(1), - g_cloudAsset.name + std::to_string(3) // 3 is insert id + g_cloudAsset.name + std::to_string(3), // 3 is insert id + g_cloudAsset.name + std::to_string(2) }; std::string sql = "SELECT asserts from " + g_tables[1] + " WHERE rowid = 0;"; sqlite3_stmt *stmt = nullptr; @@ -442,8 +443,7 @@ namespace { Assets &assets = std::get(data[j]["asserts"]); ASSERT_TRUE(assets.size() > 0); Asset &asset = assets[0]; - EXPECT_EQ(asset.status, static_cast(AssetStatus::NORMAL)); - EXPECT_EQ(asset.flag, static_cast(AssetOpType::DELETE)); + EXPECT_EQ(asset.status, static_cast(AssetStatus::DELETE)); } } @@ -1065,7 +1065,7 @@ namespace { for (auto &asset: item.second) { EXPECT_EQ(AssetOperationUtils::EraseBitMask(asset.status), static_cast(AssetStatus::DOWNLOADING)); - LOGD("asset [name]:%s, [status]:%u, [flag]:%u", asset.name.c_str(), asset.status, asset.flag); + LOGD("asset [name]:%s, [status]:%u", asset.name.c_str(), asset.status); asset.status = (index++) % 6u; // 6 is AssetStatus type num, include invalid type } } diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp index f612a0544c12ec17208f151ffb7a6b35aab9d88c..bb798ac873e6562fbb8e5c7cf81ec518ecf9828a 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp @@ -60,8 +60,12 @@ const std::vector g_cloudFiled = { const Asset g_localAsset = { .version = 1, .name = "Phone", .assetId = "0", .subpath = "/local/sync", .uri = "/local/sync", .modifyTime = "123456", .createTime = "", .size = "256", .hash = " ", - .flag = static_cast(AssetOpType::NO_CHANGE), .status = static_cast(AssetStatus::NORMAL), - .timestamp = 0L + .status = static_cast(AssetStatus::NORMAL), .timestamp = 0L +}; +const TempAsset g_localTempAsset = { + .version = 1, .name = "Phone", .assetId = "0", .subpath = "/local/sync", .uri = "/local/sync", + .modifyTime = "123456", .createTime = "", .size = "256", .hash = " ", + .status = static_cast(AssetStatus::NORMAL), .timestamp = 0L }; DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID); RelationalStoreDelegate *g_delegate = nullptr; @@ -235,20 +239,20 @@ void ConstructMultiDownloadData(int64_t count, DownloadData &downloadData, std:: Assets assets; VBucket vBucket; if (i <= 2) { // 2 is deleted or insert type - asset.flag = static_cast(i == 1 ? AssetOpType::DELETE : AssetOpType::INSERT); + // asset.flag = static_cast(i == 1 ? AssetOpType::DELETE : AssetOpType::INSERT); vBucket[CloudDbConstant::GID_FIELD] = (i == 1 ? std::to_string(i) : std::to_string(count + i)); } else { - asset.flag = static_cast(AssetOpType::UPDATE); + // asset.flag = static_cast(AssetOpType::UPDATE); vBucket[CloudDbConstant::GID_FIELD] = std::to_string(i); } vBucket["assert"] = asset; - asset.flag = static_cast(AssetOpType::NO_CHANGE); + // asset.flag = static_cast(AssetOpType::NO_CHANGE); assets.push_back(asset); - asset.flag = static_cast(AssetOpType::INSERT); + // asset.flag = static_cast(AssetOpType::INSERT); assets.push_back(asset); - asset.flag = static_cast(AssetOpType::DELETE); + // asset.flag = static_cast(AssetOpType::DELETE); assets.push_back(asset); - asset.flag = static_cast(AssetOpType::UPDATE); + // asset.flag = static_cast(AssetOpType::UPDATE); assets.push_back(asset); vBucket["asserts"] = assets; std::string name = "lisi" + std::to_string(i); @@ -306,25 +310,25 @@ int QueryCountCallback(void *data, int count, char **colValue, char **colName) void fillCloudAssetTest(int64_t count, AssetStatus statusType, bool isDownloadSuccess) { - VBucket vBucket; - vBucket[CloudDbConstant::GID_FIELD] = std::to_string(1); + AssetTypeMap assetTypeMap; + std::string gid = std::to_string(1); for (int i = 0; i < 4; i ++) { // 4 is AssetStatus Num - Asset asset = g_localAsset; - asset.flag = i; + TempAsset asset = g_localTempAsset; + // asset.flag = i; asset.status = static_cast(statusType); asset.timestamp = g_startTime; - Assets assets; + TempAssets assets; for (int j = 0; j < 4; j++) { // 4 is AssetStatus Num - Asset temp = g_localAsset; - temp.flag = j; + TempAsset temp = g_localTempAsset; + // temp.flag = j; temp.status = static_cast(statusType); temp.timestamp = g_startTime + j; assets.push_back(temp); } - vBucket["assert"] = asset; - vBucket["asserts"] = assets; + assetTypeMap["assert"] = asset; + assetTypeMap["asserts"] = assets; ASSERT_EQ(g_storageProxy->StartTransaction(TransactType::IMMEDIATE), E_OK); - ASSERT_EQ(g_storageProxy->FillCloudAssetForDownload(g_tableName, vBucket, isDownloadSuccess), E_OK); + ASSERT_EQ(g_storageProxy->FillCloudAssetForDownload(g_tableName, gid, assetTypeMap, isDownloadSuccess), E_OK); ASSERT_EQ(g_storageProxy->Commit(), E_OK); } } @@ -1135,7 +1139,7 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, FillCloudAsset002, Tes VBucket bucket1; Asset asset = g_localAsset; asset.size = "888"; - asset.flag = static_cast(AssetOpType::NO_CHANGE); + // asset.flag = static_cast(AssetOpType::NO_CHANGE); asset.status = static_cast(AssetStatus::DELETE | AssetStatus::UPLOADING); bucket1.insert_or_assign("assert", asset); int id = 0; diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h index d8a2df44140536fcb5b375d52b4c140c17b2fdec..cf62513114b22def7f5eb04d6d4a7779a1698844 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h @@ -132,7 +132,7 @@ public: { return currentContext_.currentTaskId; } - + int CallDoUpload(TaskId taskId, bool lastTable = false) { storageProxy_->StartTransaction(); @@ -180,7 +180,7 @@ public: { this->cloudDB_.SetCloudDB(icloudDB); } - + CloudTaskInfo SetAndGetCloudTaskInfo(SyncMode mode, std::vector table, SyncProcessCallback callback, int64_t timeout) { @@ -207,7 +207,7 @@ public: uploadData.delData.record = std::vector(size, tmp); uploadData.delData.extend = std::vector(size, tmp); } - + int CallTryToAddSyncTask(CloudTaskInfo &&taskInfo) { return TryToAddSyncTask(std::move(taskInfo)); @@ -235,8 +235,8 @@ public: currentContext_.assetFields[currentContext_.tableName] = assetFields; } - std::map TestTagAssetsInSingleRecord( - VBucket &coveredData, VBucket &beCoveredData, bool setNormalStatus = false) + std::map TestTagAssetsInSingleRecord( + AssetTypeMap &coveredData, AssetTypeMap &beCoveredData, bool setNormalStatus = false) { int ret = E_OK; return TagAssetsInSingleRecord(coveredData, beCoveredData, setNormalStatus, ret); diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_asset_compare_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_asset_compare_test.cpp index 544517e0f87a5be7509ba49ce5e40162fc106b7d..462ecb601c4ce1e3f93d6db94dcf2d420b6b5e6a 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_asset_compare_test.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_asset_compare_test.cpp @@ -17,6 +17,7 @@ #include #include "cloud/asset_operation_utils.h" +#include "cloud_db_types.h" #include "cloud_syncer_test.h" #include "cloud_store_types.h" #include "db_errno.h" @@ -48,39 +49,53 @@ namespace { IRelationalStore *g_store = nullptr; std::shared_ptr g_storageProxy = nullptr; std::shared_ptr g_cloudSyncer = nullptr; - Asset a1; - Asset a1Changed; - Asset a2; - Asset a2Changed; - Asset a3; - Asset a3Changed; - Asset a4; - Asset a4Changed; - Asset a5; - Asset a5Changed; + TempAsset a1; + TempAsset a1Changed; + TempAsset a2; + TempAsset a2Changed; + TempAsset a3; + TempAsset a3Changed; + TempAsset a4; + TempAsset a4Changed; + TempAsset a5; + TempAsset a5Changed; + Asset a6; + Asset a6Changed; + Asset a7; + Asset a8; const std::vector ASSET_FIELDS = { {FIELD_HOUSE, TYPE_INDEX, false}, {FIELD_CARS, TYPE_INDEX, false} }; - VBucket DATA_BASELINE; - VBucket DATA_EMPTY_ASSET; - VBucket DATA_ASSET_SAME_NAME_BUT_CHANGE; - VBucket DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED; - VBucket DATA_ALL_SAME; - VBucket DATA_ASSETS_MORE_FIELD; - VBucket DATA_EMPTY; - VBucket DATA_ASSETS_DIFFERENT_FIELD; - VBucket DATA_ASSETS_DIFFERENT_CHANGED_FIELD; - VBucket DATA_ASSETS_SAME_NAME_ALL_CHANGED; - VBucket DATA_ASSETS_ASSET_SAME_NAME; - VBucket DATA_NULL_ASSET; - VBucket DATA_ASSET_IN_ASSETS; - VBucket DATA_NULL_ASSETS; - VBucket DATA_ALL_NULL_ASSETS; - VBucket DATA_EMPTY_ASSETS; - VBucket DATA_UPDATE_DELTE_NOCHANGE_INSERT; - VBucket DATA_SAME_NAME_ASSETS; - - Asset GenAsset(std::string name, std::string hash) + AssetTypeMap DATA_BASELINE; + AssetTypeMap DATA_EMPTY_ASSET; + AssetTypeMap DATA_ASSET_SAME_NAME_BUT_CHANGE; + AssetTypeMap DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED; + AssetTypeMap DATA_ALL_SAME; + AssetTypeMap DATA_ASSETS_MORE_FIELD; + AssetTypeMap DATA_EMPTY; + AssetTypeMap DATA_ASSETS_DIFFERENT_FIELD; + AssetTypeMap DATA_ASSETS_DIFFERENT_CHANGED_FIELD; + AssetTypeMap DATA_ASSETS_SAME_NAME_ALL_CHANGED; + AssetTypeMap DATA_ASSETS_ASSET_SAME_NAME; + AssetTypeMap DATA_NULL_ASSET; + AssetTypeMap DATA_ASSET_IN_ASSETS; + AssetTypeMap DATA_NULL_ASSETS; + AssetTypeMap DATA_ALL_NULL_ASSETS; + AssetTypeMap DATA_EMPTY_ASSETS; + AssetTypeMap DATA_UPDATE_DELTE_NOCHANGE_INSERT; + AssetTypeMap DATA_SAME_NAME_ASSETS; + VBucket VBUCKET_DATA_SAME_NAME_ASSETS; + VBucket VBUCKET_DATA_BASELINE; + + TempAsset GenAsset(std::string name, std::string hash) + { + TempAsset asset; + asset.name = name; + asset.hash = hash; + return asset; + } + + Asset GenerateAsset(std::string name, std::string hash) { Asset asset; asset.name = name; @@ -88,6 +103,16 @@ namespace { return asset; } + AssetTypeMap GenDatum(AssetType asset, AssetType assets) + { + AssetTypeMap datum; + // datum[FIELD_ID] = id; + // datum[FIELD_NAME] = name; + datum[FIELD_HOUSE] = asset; + datum[FIELD_CARS] = assets; + return datum; + } + VBucket GenDatum(int64_t id, std::string name, Type asset, Type assets) { VBucket datum; @@ -110,28 +135,34 @@ namespace { a4Changed = GenAsset("sedan", "sedan1Changed"); a5 = GenAsset("trucker", "truck1"); a5Changed = GenAsset("trucker", "truck1Changed"); + a6 = GenerateAsset("mansion", "mansion1"); + a6Changed = GenerateAsset("mansion", "mansion1Changed"); + a7 = GenerateAsset("suv", "suv1"); + a8 = GenerateAsset("truck", "truck1"); DATA_EMPTY.clear(); - DATA_BASELINE = GenDatum(1, "Jack", a1, Assets({a2, a3, a4})); // id is 1 - DATA_EMPTY_ASSET = GenDatum(2, "PoorGuy", a1, Assets({})); // id is 2 + DATA_BASELINE = GenDatum(a1, TempAssets({a2, a3, a4})); // id is 1 + DATA_EMPTY_ASSET = GenDatum(a1, TempAssets({})); // id is 2 DATA_EMPTY_ASSET.erase(FIELD_HOUSE); - DATA_ASSET_SAME_NAME_BUT_CHANGE = GenDatum(3, "Alice", a1Changed, Assets({a2, a3, a4})); // id is 3 - DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED = GenDatum(4, "David", a1, Assets({a2, a3Changed, a4})); // id is 4 - DATA_ALL_SAME = GenDatum(5, "Marry", a1, Assets({a2, a3, a4})); // id is 5 - DATA_ASSETS_MORE_FIELD = GenDatum(6, "Carl", a1, Assets({a2, a3, a4, a5})); // id is 6 - DATA_ASSETS_DIFFERENT_FIELD = GenDatum(7, "Carllol", a1, Assets({a2, a3, a5})); // id is 7 - DATA_ASSETS_DIFFERENT_CHANGED_FIELD = GenDatum(8, "Carllol", a1, Assets({a2, a3Changed, a5})); // id is 8 + DATA_ASSET_SAME_NAME_BUT_CHANGE = GenDatum(a1Changed, TempAssets({a2, a3, a4})); // id is 3 + DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED = GenDatum(a1, TempAssets({a2, a3Changed, a4})); // id is 4 + DATA_ALL_SAME = GenDatum(a1, TempAssets({a2, a3, a4})); // id is 5 + DATA_ASSETS_MORE_FIELD = GenDatum(a1, TempAssets({a2, a3, a4, a5})); // id is 6 + DATA_ASSETS_DIFFERENT_FIELD = GenDatum(a1, TempAssets({a2, a3, a5})); // id is 7 + DATA_ASSETS_DIFFERENT_CHANGED_FIELD = GenDatum(a1, TempAssets({a2, a3Changed, a5})); // id is 8 DATA_ASSETS_SAME_NAME_ALL_CHANGED = GenDatum( - 9, "Lob", a1Changed, Assets({a2Changed, a3Changed, a4Changed})); // id is 9 - DATA_ASSETS_ASSET_SAME_NAME = GenDatum(10, "Lob2", a1, Assets({a1, a2, a3})); // id is 10 + a1Changed, TempAssets({a2Changed, a3Changed, a4Changed})); // id is 9 + DATA_ASSETS_ASSET_SAME_NAME = GenDatum(a1, TempAssets({a1, a2, a3})); // id is 10 std::monostate nil; - DATA_NULL_ASSET = GenDatum(11, "Lob3", nil, Assets({a1, a2, a3})); // id is 11 - DATA_ASSET_IN_ASSETS = GenDatum(12, "Lob4", Assets({a1}), Assets({a2, a3, a4})); // id is 12 - DATA_NULL_ASSETS = GenDatum(13, "Lob5", Assets({a1}), nil); // id is 13 - DATA_ALL_NULL_ASSETS = GenDatum(14, "Nico", nil, nil); // id is 14 - DATA_EMPTY_ASSETS = GenDatum(15, "Lob6", a1, Assets({})); // id is 15 + DATA_NULL_ASSET = GenDatum(nil, TempAssets({a1, a2, a3})); // id is 11 + DATA_ASSET_IN_ASSETS = GenDatum(TempAssets({a1}), TempAssets({a2, a3, a4})); // id is 12 + DATA_NULL_ASSETS = GenDatum(TempAssets({a1}), nil); // id is 13 + DATA_ALL_NULL_ASSETS = GenDatum(nil, nil); // id is 14 + DATA_EMPTY_ASSETS = GenDatum(a1, TempAssets({})); // id is 15 DATA_EMPTY_ASSETS.erase(FIELD_CARS); - DATA_UPDATE_DELTE_NOCHANGE_INSERT = GenDatum(16, "Nico321", nil, Assets({a2Changed, a4, a5})); // id is 16 - DATA_SAME_NAME_ASSETS = GenDatum(16, "Nico156", nil, Assets({a1, a1Changed})); // id is 16 + DATA_UPDATE_DELTE_NOCHANGE_INSERT = GenDatum(nil, TempAssets({a2Changed, a4, a5})); // id is 16 + DATA_SAME_NAME_ASSETS = GenDatum(nil, TempAssets({a1, a1Changed})); // id is 16 + VBUCKET_DATA_SAME_NAME_ASSETS = GenDatum(16, "Nico156", nil, Assets({a6, a6Changed})); // id is 16 + VBUCKET_DATA_BASELINE = GenDatum(1, "Jack", a6, Assets({a7, a8})); // id is 1 } void CreateDB() @@ -224,7 +255,7 @@ namespace { } } - static bool IsAssetEq(Asset &target, Asset &expected) + static bool IsAssetEq(TempAsset &target, TempAsset &expected) { if (target.name != expected.name || target.flag != expected.flag || @@ -234,8 +265,8 @@ namespace { return true; } - static bool CheckAssetDownloadList(std::string fieldName, std::map &target, - std::map &expected) + static bool CheckAssetDownloadList(std::string fieldName, std::map &target, + std::map &expected) { if (target[fieldName].size() != expected[fieldName].size()) { LOGE("[CheckAssetDownloadList] size is not equal actual %zu expect %zu", target[fieldName].size(), @@ -251,7 +282,7 @@ namespace { return true; } - static void TagAsset(AssetOpType flag, AssetStatus status, Asset &asset) + static void TagAsset(AssetOpType flag, AssetStatus status, TempAsset &asset) { asset.flag = static_cast(flag); asset.status = static_cast(status); @@ -272,7 +303,7 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest001, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_EMPTY); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a1); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a2); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a3); @@ -293,7 +324,7 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest002, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_EMPTY_ASSET); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a1); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a2); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a3); @@ -314,7 +345,7 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest003, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_ASSET_SAME_NAME_BUT_CHANGE); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a1); expectedList[FIELD_HOUSE] = { a1 }; expectedList[FIELD_CARS] = { a2, a3, a4 }; @@ -333,7 +364,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a3); expectedList[FIELD_HOUSE] = {}; expectedList[FIELD_CARS] = { a2, a3, a4 }; @@ -352,7 +383,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ALL_SAME); - std::map expectedList; + std::map expectedList; expectedList[FIELD_HOUSE] = {}; expectedList[FIELD_CARS] = { a2, a3, a4 }; ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); @@ -370,7 +401,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSETS_MORE_FIELD); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a5); expectedList[FIELD_HOUSE] = {}; expectedList[FIELD_CARS] = { a2, a3, a4, a5 }; @@ -389,7 +420,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSETS_DIFFERENT_FIELD); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a5); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a4); expectedList[FIELD_HOUSE] = {}; @@ -409,7 +440,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSETS_DIFFERENT_CHANGED_FIELD); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a3); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a5); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a4); @@ -430,7 +461,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSETS_SAME_NAME_ALL_CHANGED); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a1); TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a2); TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a3); @@ -452,7 +483,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_EMPTY_ASSET, DATA_BASELINE); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a1); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a2); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a3); @@ -474,7 +505,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_EMPTY_ASSET, DATA_ASSETS_ASSET_SAME_NAME); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a1); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a2); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a3); @@ -495,7 +526,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_EMPTY_ASSET, DATA_ASSETS_ASSET_SAME_NAME); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a1); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a2); TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a3); @@ -516,7 +547,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSET_IN_ASSETS); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a1); TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a2); TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a3); @@ -540,7 +571,7 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_NULL_ASSETS); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a1); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a2); TagAsset(AssetOpType::INSERT, GetDownloadWithNullStatus(), a3); @@ -562,7 +593,7 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest015, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_ASSET_SAME_NAME_BUT_CHANGE, DATA_BASELINE); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a1Changed); expectedList[FIELD_HOUSE] = { a1Changed }; expectedList[FIELD_CARS] = {a2, a3, a4}; @@ -580,7 +611,7 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest016, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_ASSET_SAME_NAME_BUT_CHANGE); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::UPDATE)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::UPDATE)); } /** @@ -594,9 +625,9 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED, true); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::UPDATE)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::NO_CHANGE)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::NO_CHANGE)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::UPDATE)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::NO_CHANGE)); } /** @@ -610,10 +641,10 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_EMPTY, true); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); } /** @@ -627,9 +658,9 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_EMPTY, DATA_BASELINE, true); - EXPECT_EQ(std::get(DATA_EMPTY[FIELD_CARS])[0].flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_EMPTY[FIELD_CARS])[1].flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_EMPTY[FIELD_CARS])[2].flag, static_cast(AssetOpType::DELETE)); + EXPECT_EQ(std::get(DATA_EMPTY[FIELD_CARS])[0].flag, static_cast(AssetOpType::DELETE)); + EXPECT_EQ(std::get(DATA_EMPTY[FIELD_CARS])[1].flag, static_cast(AssetOpType::DELETE)); + EXPECT_EQ(std::get(DATA_EMPTY[FIELD_CARS])[2].flag, static_cast(AssetOpType::DELETE)); } /** @@ -643,15 +674,15 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_ALL_NULL_ASSETS, DATA_BASELINE, true); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[0].flag, + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::DELETE)); + EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[0].flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[1].flag, + EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[1].flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[2].flag, + EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[2].flag, static_cast(AssetOpType::DELETE)); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a1); TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a2); TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a3); @@ -676,7 +707,7 @@ namespace { ASSERT_TRUE(DATA_ALL_NULL_ASSETS[FIELD_HOUSE].index() == TYPE_INDEX); ASSERT_TRUE(DATA_ALL_NULL_ASSETS[FIELD_CARS].index() == TYPE_INDEX); - std::map expectedList; + std::map expectedList; expectedList[FIELD_HOUSE] = {}; expectedList[FIELD_CARS] = {}; ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); @@ -694,12 +725,12 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_BASELINE, DATA_ALL_NULL_ASSETS, true); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); - std::map expectedList; + std::map expectedList; TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a1); TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a2); TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a3); @@ -721,13 +752,13 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_ASSET_SAME_NAME_BUT_CHANGE, DATA_BASELINE, true); - EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_HOUSE]).flag, + EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_HOUSE]).flag, static_cast(AssetOpType::UPDATE)); - EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[0].flag, + EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[0].flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[1].flag, + EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[1].flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[2].flag, + EXPECT_EQ(std::get(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[2].flag, static_cast(AssetOpType::NO_CHANGE)); } @@ -742,15 +773,15 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_ASSETS_DIFFERENT_CHANGED_FIELD, DATA_BASELINE, true); - EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_HOUSE]).flag, + EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_HOUSE]).flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[0].flag, + EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[0].flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[1].flag, + EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[1].flag, static_cast(AssetOpType::UPDATE)); - EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[2].flag, + EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[3].flag, + EXPECT_EQ(std::get(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[3].flag, static_cast(AssetOpType::DELETE)); } @@ -765,10 +796,10 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest025, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_NULL_ASSETS, true); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::NO_CHANGE)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); } /** @@ -783,10 +814,10 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest026, TestSize.Level0) { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_EMPTY_ASSETS, true); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast(AssetOpType::NO_CHANGE)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast(AssetOpType::INSERT)); + EXPECT_EQ(std::get(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); } /** @@ -800,13 +831,13 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_UPDATE_DELTE_NOCHANGE_INSERT, DATA_BASELINE, false); - EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[0].flag, + EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[0].flag, static_cast(AssetOpType::UPDATE)); - EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[1].flag, + EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[1].flag, static_cast(AssetOpType::NO_CHANGE)); - EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[2].flag, + EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[2].flag, static_cast(AssetOpType::INSERT)); - EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[3].flag, + EXPECT_EQ(std::get(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[3].flag, static_cast(AssetOpType::DELETE)); } @@ -821,11 +852,11 @@ namespace { { auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( DATA_ALL_NULL_ASSETS, DATA_BASELINE, true); - EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[0].flag, + EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[0].flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[1].flag, + EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[1].flag, static_cast(AssetOpType::DELETE)); - EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[2].flag, + EXPECT_EQ(std::get(DATA_ALL_NULL_ASSETS[FIELD_CARS])[2].flag, static_cast(AssetOpType::DELETE)); } @@ -841,8 +872,8 @@ namespace { Field field1 = { FIELD_HOUSE, TYPE_INDEX }; Field field2 = { FIELD_CARS, TYPE_INDEX }; std::vector assetFields = { field1, field2 }; - ASSERT_TRUE(g_cloudSyncer->TestIsDataContainDuplicateAsset(assetFields, DATA_SAME_NAME_ASSETS)); - ASSERT_TRUE(g_cloudSyncer->TestIsDataContainDuplicateAsset(assetFields, DATA_BASELINE) == false); + ASSERT_TRUE(g_cloudSyncer->TestIsDataContainDuplicateAsset(assetFields, VBUCKET_DATA_SAME_NAME_ASSETS)); + ASSERT_TRUE(g_cloudSyncer->TestIsDataContainDuplicateAsset(assetFields, VBUCKET_DATA_BASELINE) == false); } /** @@ -854,12 +885,15 @@ namespace { */ HWTEST_F(DistributedDBCloudAssetCompareTest, AssetOperation001, TestSize.Level0) { - VBucket cacheAssets; + AssetTypeMap cacheAssets; VBucket dbAssets; Asset asset; asset.status = AssetStatus::DOWNLOADING; asset.name = "name"; - cacheAssets["field"] = asset; + TempAsset tempAsset; + tempAsset.status = AssetStatus::DOWNLOADING; + tempAsset.name = "name"; + cacheAssets["field"] = tempAsset; dbAssets["field"] = asset; // check both downloading after download auto res = AssetOperationUtils::CalAssetOperation(cacheAssets, dbAssets, @@ -869,7 +903,9 @@ namespace { // status mask download with null asset.status = (static_cast(AssetStatus::DOWNLOADING) | static_cast(AssetStatus::DOWNLOAD_WITH_NULL)); - cacheAssets["field"] = asset; + tempAsset.status = (static_cast(AssetStatus::DOWNLOADING) | + static_cast(AssetStatus::DOWNLOAD_WITH_NULL)); + cacheAssets["field"] = tempAsset; dbAssets["field"] = asset; res = AssetOperationUtils::CalAssetOperation(cacheAssets, dbAssets, AssetOperationUtils::CloudSyncAction::END_DOWNLOAD); @@ -897,12 +933,15 @@ namespace { */ HWTEST_F(DistributedDBCloudAssetCompareTest, AssetOperation002, TestSize.Level0) { - VBucket cacheAssets; + AssetTypeMap cacheAssets; VBucket dbAssets; Asset asset; asset.name = "name"; asset.status = AssetStatus::DOWNLOADING; - cacheAssets["field"] = asset; + TempAsset tempAsset; + tempAsset.status = AssetStatus::DOWNLOADING; + tempAsset.name = "name"; + cacheAssets["field"] = tempAsset; dbAssets["field"] = asset; // check both downloading before download auto res = AssetOperationUtils::CalAssetOperation(cacheAssets, dbAssets, @@ -921,8 +960,8 @@ namespace { AssetOperationUtils::CloudSyncAction::START_DOWNLOAD); EXPECT_EQ(res["field"][asset.name], AssetOperationUtils::AssetOpType::NOT_HANDLE); // if db asset not exist but cache is delete, handle - asset.flag = static_cast(AssetOpType::DELETE); - cacheAssets["field"] = asset; + tempAsset.flag = static_cast(AssetOpType::DELETE); + cacheAssets["field"] = tempAsset; res = AssetOperationUtils::CalAssetOperation(cacheAssets, dbAssets, AssetOperationUtils::CloudSyncAction::START_DOWNLOAD); EXPECT_EQ(res["field"][asset.name], AssetOperationUtils::AssetOpType::HANDLE); @@ -938,11 +977,14 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetOperation003, TestSize.Level0) { Asset asset; - VBucket cacheAssets; + AssetTypeMap cacheAssets; VBucket dbAssets; asset.name = "name"; asset.status = AssetStatus::UPDATE; - cacheAssets["field"] = asset; + TempAsset tempAsset; + tempAsset.name = "name"; + tempAsset.status = AssetStatus::UPDATE; + cacheAssets["field"] = tempAsset; dbAssets["field"] = asset; // check both update before upload auto res = AssetOperationUtils::CalAssetOperation(cacheAssets, dbAssets, @@ -972,11 +1014,14 @@ namespace { HWTEST_F(DistributedDBCloudAssetCompareTest, AssetOperation004, TestSize.Level0) { Asset asset; - VBucket cacheAssets; + AssetTypeMap cacheAssets; VBucket dbAssets; asset.name = "name"; asset.status = (static_cast(AssetStatus::UPDATE) | static_cast(AssetStatus::UPLOADING)); - cacheAssets["field"] = asset; + TempAsset tempAsset; + tempAsset.name = "name"; + tempAsset.status = (static_cast(AssetStatus::UPDATE) | static_cast(AssetStatus::UPLOADING)); + cacheAssets["field"] = tempAsset; dbAssets["field"] = asset; // check both UPLOADING after upload auto res = AssetOperationUtils::CalAssetOperation(cacheAssets, dbAssets, diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp index 1e86dc005ed8873434b904a0705ff35d1793f6ad..d504bbb38641b1627510794d5213facc885a013d 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp @@ -257,12 +257,11 @@ void CheckDownloadForTest001(int index, map &assets) for (auto &asset : item.second) { EXPECT_EQ(AssetOperationUtils::EraseBitMask(asset.status), static_cast(AssetStatus::DOWNLOADING)); if (index > 4) { // 1-4 is deleted; 5-8 is inserted - EXPECT_EQ(asset.flag, static_cast(AssetOpType::INSERT)); + // EXPECT_EQ(asset.flag, static_cast(AssetOpType::INSERT)); } else { - EXPECT_EQ(asset.flag, static_cast(AssetOpType::DELETE)); + // EXPECT_EQ(asset.flag, static_cast(AssetOpType::DELETE)); } - LOGD("asset [name]:%s, [status]:%u, [flag]:%u, [index]:%d", asset.name.c_str(), asset.status, asset.flag, - index); + LOGD("asset [name]:%s, [status]:%u, [index]:%d", asset.name.c_str(), asset.status, index); } } } @@ -1121,11 +1120,11 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, DownloadAssetForDupDataTest .WillRepeatedly( [&](const std::string &, const std::string &gid, const Type &, std::map &assets) { LOGD("Download GID:%s, index:%d", gid.c_str(), ++index); - for (auto &item : assets) { - for (auto &asset : item.second) { - asset.flag = static_cast(AssetOpType::NO_CHANGE); - } - } + // for (auto &item : assets) { + // for (auto &asset : item.second) { + // asset.flag = static_cast(AssetOpType::NO_CHANGE); + // } + // } return DBStatus::CLOUD_ERROR; }); diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/mock_icloud_sync_storage_interface.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/mock_icloud_sync_storage_interface.h index 22275b2296f5506605fcea7ce3633b430524022e..8c0d78fb202202d61b8c087960cfeb7db6998d81 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/mock_icloud_sync_storage_interface.h +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/mock_icloud_sync_storage_interface.h @@ -41,7 +41,7 @@ public: MOCK_METHOD3(TriggerObserverAction, void(const std::string &, ChangedData &&, bool)); MOCK_METHOD4(CleanCloudData, int(ClearMode mode, const std::vector &tableNameList, const RelationalSchemaObject &localSchema, std::vector &assets)); - MOCK_METHOD3(FillCloudAssetForDownload, int(const std::string &, VBucket &, bool)); + MOCK_METHOD4(FillCloudAssetForDownload, int(const std::string &, const std::string &, AssetTypeMap &, bool)); MOCK_METHOD1(SetLogTriggerStatus, int(bool)); MOCK_METHOD4(FillCloudLogAndAsset, int(OpType, const CloudSyncData &, bool, bool)); MOCK_CONST_METHOD0(GetIdentify, std::string()); diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp index 10e656a16dc417c08c05bc4fd580cb542633d9fb..cef972dd5217bb2f218a219a4facf902186b6523 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp @@ -31,7 +31,7 @@ DBStatus VirtualAssetLoader::Download(const std::string &tableName, const std::s } for (auto &item: assets) { for (auto &asset: item.second) { - LOGD("asset [name]:%s, [status]:%u, [flag]:%u", asset.name.c_str(), asset.status, asset.flag); + LOGD("asset [name]:%s, [status]:%u", asset.name.c_str(), asset.status); asset.status = static_cast(AssetStatus::NORMAL); } } @@ -46,6 +46,12 @@ DBStatus VirtualAssetLoader::RemoveLocalAssets(const std::vector &assets) return DBStatus::OK; } +DBStatus VirtualAssetLoader::RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix, + const std::map &assets) +{ + return DBStatus::OK; +} + void VirtualAssetLoader::SetDownloadStatus(DBStatus status) { std::lock_guard autoLock(dataMutex_); diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h index c299be70b6b966e383ff69ed4f7a8c89eec55b00..14d16ed422cbc077cd3887fe553bd27225d508c4 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h @@ -31,6 +31,9 @@ public: DBStatus RemoveLocalAssets(const std::vector &assets) override; + DBStatus RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix, + const std::map &assets) override; + void SetDownloadStatus(DBStatus status); void ForkDownload(const DownloadCallBack &callback); diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp index 76e338ff645ca23460e4933b7733ddb8a97ab3f5..c86178e9f2a8a605277e20310305cc7fd0c4f92c 100644 --- a/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp +++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp @@ -562,7 +562,7 @@ void VirtualCloudDb::AddAssetIdForExtend(VBucket &record, VBucket &extend) for (auto &recordData : record) { if (recordData.second.index() == TYPE_INDEX) { auto &asset = std::get(recordData.second); - if (asset.flag == static_cast(DistributedDB::AssetOpType::INSERT)) { + if (asset.status == static_cast(DistributedDB::AssetStatus::INSERT)) { asset.assetId = "10"; } extend[recordData.first] = asset; @@ -578,7 +578,7 @@ void VirtualCloudDb::AddAssetIdForExtend(VBucket &record, VBucket &extend) void VirtualCloudDb::AddAssetsIdInner(Assets &assets) { for (auto &asset : assets) { - if (asset.flag == static_cast(DistributedDB::AssetOpType::INSERT)) { + if (asset.status == static_cast(DistributedDB::AssetStatus::INSERT)) { asset.assetId = "10"; } }