Description: adapter media analysis service

Signed-off-by: lumingfei0525 <zhouhui86@huawei.com>

frameworks/innerkitsimpl/medialibrary_data_extension/BUILD.gn

@@ -149,6 +149,7 @@ ohos_shared_library("medialibrary_data_extension") {
     "src/medialibrary_smartalbum_operations.cpp",
     "src/medialibrary_subscriber.cpp",
     "src/medialibrary_uripermission_operations.cpp",
+    "src/medialibrary_vision_operations.cpp",
     "src/photo_map_operations.cpp",
     "src/trash_async_worker.cpp",
   ]

frameworks/innerkitsimpl/medialibrary_data_extension/include/medialibrary_command.h

@@ -56,6 +56,11 @@ enum class OperationObject : uint32_t {
     PAH_MAP,
     TOOL_PHOTO,
     TOOL_AUDIO,
+    VISION_OCR,              // Vision start 
+    VISION_LABEL,
+    VISION_AESTHETICS,
+    VISION_TOTAL,
+    VISION_SHIELD,           // Vision end
 };
 
 enum class OperationType : uint32_t {

frameworks/innerkitsimpl/medialibrary_data_extension/include/medialibrary_vision_operations.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_MEDIALIBRARY_VISION_OPERATIOINS_H
+#define OHOS_MEDIALIBRARY_VISION_OPERATIOINS_H
+
+#include <string>
+#include <unordered_map>
+
+#include "abs_shared_result_set.h"
+#include "medialibrary_command.h"
+
+namespace OHOS {
+namespace Media {
+class MediaLibraryVisionOperations {
+public:
+    static int32_t InsertOperation(MediaLibraryCommand &cmd);
+    static int32_t UpdateOperation(MediaLibraryCommand &cmd);
+    static int32_t DeleteOperation(MediaLibraryCommand &cmd);
+    static std::shared_ptr<NativeRdb::ResultSet> QueryOperation(MediaLibraryCommand &cmd,
+        const std::vector<std::string> &columns);
+};
+} // namespace Media
+} // namespace OHOS
+#endif // OHOS_MEDIALIBRARY_VISION_OPERATIOINS_H

frameworks/innerkitsimpl/medialibrary_data_extension/src/medialibrary_command.cpp

@@ -26,6 +26,7 @@
 #include "photo_map_column.h"
 #include "medialibrary_errno.h"
 #include "userfilemgr_uri.h"
+#include "vision_column.h"
 
 using namespace std;
 using namespace OHOS::NativeRdb;
@@ -252,6 +253,13 @@ void MediaLibraryCommand::ParseOprnObjectFromUri()
         { SMARTALBUM_TABLE, OperationObject::SMART_ALBUM },
         { SMARTALBUM_MAP_TABLE, OperationObject::SMART_ALBUM_MAP },
         { MEDIA_QUERYOPRN_QUERYVOLUME, OperationObject::MEDIA_VOLUME },
+
+        // use in Vision
+        { VISION_OCR_TABLE, OperationObject::VISION_OCR },
+        { VISION_LABEL_TABLE, OperationObject::VISION_LABEL },
+        { VISION_AESTHETICS_TABLE, OperationObject::VISION_AESTHETICS },
+        { VISION_TOTAL_TABLE, OperationObject::VISION_TOTAL },
+        { VISION_SHIELD_TABLE, OperationObject::VISION_SHIELD },
     };
 
     const string opObject = MediaFileUri::GetPathFirstDentry(uri_);
@@ -365,6 +373,11 @@ void MediaLibraryCommand::ParseTableName()
         { OperationObject::PAH_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
         { OperationObject::TOOL_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
         { OperationObject::TOOL_AUDIO, { { OperationType::UNKNOWN_TYPE, AudioColumn::AUDIOS_TABLE } } },
+        { OperationObject::VISION_OCR, { { OperationType::UNKNOWN_TYPE, VISION_OCR_TABLE } } },
+        { OperationObject::VISION_LABEL, { { OperationType::UNKNOWN_TYPE, VISION_LABEL_TABLE } } },
+        { OperationObject::VISION_AESTHETICS, { { OperationType::UNKNOWN_TYPE, VISION_AESTHETICS_TABLE } } },
+        { OperationObject::VISION_TOTAL, { { OperationType::UNKNOWN_TYPE, VISION_TOTAL_TABLE } } },
+        { OperationObject::VISION_SHIELD, { { OperationType::UNKNOWN_TYPE, VISION_SHIELD_TABLE } } },
     };
 
     if (TABLE_NAME_MAP.find(oprnObject_) != TABLE_NAME_MAP.end()) {

frameworks/innerkitsimpl/medialibrary_data_extension/src/medialibrary_data_manager.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
+ * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -54,6 +54,7 @@
 #include "medialibrary_tracer.h"
 #include "medialibrary_unistore_manager.h"
 #include "medialibrary_uripermission_operations.h"
+#include "medialibrary_vision_operations.h"
 #include "mimetype_utils.h"
 #include "permission_utils.h"
 #include "photo_map_operations.h"
@@ -394,6 +395,13 @@ int32_t MediaLibraryDataManager::SolveInsertCmd(MediaLibraryCommand &cmd)
         case OperationObject::BUNDLE_PERMISSION: {
             return UriPermissionOperations::HandleUriPermOperations(cmd);
         }
+        case OperationObject::VISION_OCR:
+        case OperationObject::VISION_LABEL:
+        case OperationObject::VISION_AESTHETICS:
+        case OperationObject::VISION_TOTAL:
+        case OperationObject::VISION_SHIELD: {
+            return MediaLibraryVisionOperations::InsertOperation(cmd);
+        }
         default: {
             MEDIA_ERR_LOG("MediaLibraryDataManager SolveInsertCmd: unsupported OperationObject: %{public}d",
                 cmd.GetOprnObject());
@@ -544,6 +552,13 @@ int32_t MediaLibraryDataManager::Delete(MediaLibraryCommand &cmd, const DataShar
         case OperationObject::FILESYSTEM_AUDIO: {
             return MediaLibraryAssetOperations::DeleteOperation(cmd);
         }
+        case OperationObject::VISION_OCR:
+        case OperationObject::VISION_LABEL:
+        case OperationObject::VISION_AESTHETICS:
+        case OperationObject::VISION_TOTAL:
+        case OperationObject::VISION_SHIELD: {
+            return MediaLibraryVisionOperations::DeleteOperation(cmd);
+        }
         default:
             break;
     }
@@ -573,8 +588,11 @@ int32_t MediaLibraryDataManager::Update(MediaLibraryCommand &cmd, const DataShar
 
     cmd.SetValueBucket(value);
     cmd.SetDataSharePred(predicates);
-    cmd.GetAbsRdbPredicates()->SetWhereClause(predicates.GetWhereClause());
-    cmd.GetAbsRdbPredicates()->SetWhereArgs(predicates.GetWhereArgs());
+    // MEDIALIBRARY_TABLE just for RdbPredicates
+    NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates,
+        cmd.GetTableName());
+    cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
+    cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
 
     switch (cmd.GetOprnObject()) {
         case OperationObject::FILESYSTEM_ASSET: {
@@ -599,6 +617,13 @@ int32_t MediaLibraryDataManager::Update(MediaLibraryCommand &cmd, const DataShar
         case OperationObject::PHOTO_ALBUM: {
             return MediaLibraryAlbumOperations::HandlePhotoAlbum(cmd.GetOprnType(), value, predicates);
         }
+        case OperationObject::VISION_OCR:
+        case OperationObject::VISION_LABEL:
+        case OperationObject::VISION_AESTHETICS:
+        case OperationObject::VISION_TOTAL:
+        case OperationObject::VISION_SHIELD: {
+            return MediaLibraryVisionOperations::UpdateOperation(cmd);
+        }
         default:
             break;
     }

frameworks/innerkitsimpl/medialibrary_data_extension/src/medialibrary_file_operations.cpp

@@ -501,6 +501,12 @@ shared_ptr<NativeRdb::ResultSet> MediaLibraryFileOperations::QueryFileOperation(
         return nullptr;
     }
 
+    // for vision table
+    OperationObject oprnObject = cmd.GetOprnObject();
+    if (oprnObject >= OperationObject::VISION_OCR && oprnObject <= OperationObject::VISION_SHIELD) {
+        return uniStore->Query(cmd, columns);
+    }
+
     string fileId = cmd.GetOprnFileId();
     if (cmd.GetAbsRdbPredicates()->GetWhereClause().empty() && !fileId.empty()) {
         cmd.GetAbsRdbPredicates()->EqualTo(MEDIA_DATA_DB_ID, fileId);

frameworks/innerkitsimpl/medialibrary_data_extension/src/medialibrary_rdbstore.cpp

@@ -39,6 +39,7 @@
 #include "rdb_sql_utils.h"
 #include "result_set_utils.h"
 #include "post_event_utils.h"
+#include "vision_column.h"
 
 using namespace std;
 using namespace OHOS::NativeRdb;
@@ -1372,6 +1373,23 @@ void UpgradeOtherTable(RdbStore &store, int32_t oldVersion)
     }
 }
 
+static void AddVisionTables(RdbStore &store)
+{
+    static const vector<string> executeSqlStrs = {
+        CREATE_TAB_ANALYSIS_OCR,
+        CREATE_TAB_ANALYSIS_LABEL,
+        CREATE_TAB_ANALYSIS_AESTHETICS,
+        CREATE_TAB_ANALYSIS_TOTAL,
+        CREATE_TAB_APPLICATION_SHIELD,
+        CREATE_VISION_UPDATE_TRIGGER,
+        CREATE_VISION_DELETE_TRIGGER,
+        CREATE_VISION_INSERT_TRIGGER,
+        INIT_TAB_ANALYSIS_TOTAL,
+    };
+    MEDIA_INFO_LOG("start init vision db");
+    ExecSqls(executeSqlStrs, store);
+}
+
 int32_t MediaLibraryDataCallBack::OnUpgrade(RdbStore &store, int32_t oldVersion, int32_t newVersion)
 {
     MEDIA_DEBUG_LOG("OnUpgrade old:%d, new:%d", oldVersion, newVersion);
@@ -1418,6 +1436,10 @@ int32_t MediaLibraryDataCallBack::OnUpgrade(RdbStore &store, int32_t oldVersion,
         VariantMap map = {{KEY_PRE_VERSION, oldVersion}, {KEY_AFTER_VERSION, newVersion}};
         PostEventUtils::GetInstance().PostStatProcess(StatType::DB_UPGRADE_STAT, map);
     }
+
+    if (oldVersion < VERSION_ADD_VISION_TABLE) {
+        AddVisionTables(store);
+    }
     return NativeRdb::E_OK;
 }
 

frameworks/innerkitsimpl/medialibrary_data_extension/src/medialibrary_vision_operations.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define MLOG_TAG "VisionOperation"
+
+#include "media_log.h"
+#include "medialibrary_data_manager_utils.h"
+#include "medialibrary_db_const.h"
+#include "medialibrary_errno.h"
+#include "medialibrary_unistore_manager.h"
+#include "medialibrary_vision_operations.h"
+
+using namespace std;
+using namespace OHOS::NativeRdb;
+
+namespace OHOS {
+namespace Media {
+
+int32_t MediaLibraryVisionOperations::InsertOperation(MediaLibraryCommand &cmd)
+{
+    auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
+    if (rdbStore == nullptr) {
+        return E_HAS_DB_ERROR;
+    }
+    int64_t outRowId = -1;
+    int32_t errCode = rdbStore->Insert(cmd, outRowId);
+    if (errCode != NativeRdb::E_OK || outRowId < 0) {
+        MEDIA_ERR_LOG("Insert into db failed, errCode = %{public}d", errCode);
+        return E_HAS_DB_ERROR;
+    }
+    return static_cast<int32_t>(outRowId);
+}
+
+int32_t MediaLibraryVisionOperations::UpdateOperation(MediaLibraryCommand &cmd)
+{
+    auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
+    if (rdbStore == nullptr) {
+        return E_HAS_DB_ERROR;
+    }
+    int32_t updateRows = -1;
+    int32_t errCode = rdbStore->Update(cmd, updateRows);
+    if (errCode != NativeRdb::E_OK || updateRows < 0) {
+        MEDIA_ERR_LOG("Update db failed, errCode = %{public}d", errCode);
+        return E_HAS_DB_ERROR;
+    }
+    return static_cast<int32_t>(updateRows);
+}
+
+int32_t MediaLibraryVisionOperations::DeleteOperation(MediaLibraryCommand &cmd)
+{
+    auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
+    if (rdbStore == nullptr) {
+        return E_HAS_DB_ERROR;
+    }
+    int32_t deleteRows = -1;
+    int32_t errCode = rdbStore->Delete(cmd, deleteRows);
+    if (errCode != NativeRdb::E_OK || deleteRows < 0) {
+        MEDIA_ERR_LOG("Delete db failed, errCode = %{public}d", errCode);
+        return E_HAS_DB_ERROR;
+    }
+    return static_cast<int32_t>(deleteRows);
+}
+
+shared_ptr<NativeRdb::ResultSet> MediaLibraryVisionOperations::QueryOperation(MediaLibraryCommand &cmd,
+    const std::vector<std::string> &columns)
+{
+    auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
+    if (rdbStore == nullptr) {
+        return nullptr;
+    }
+    return rdbStore->Query(cmd, columns);
+}
+}
+}

frameworks/innerkitsimpl/test/BUILD.gn

@@ -1,4 +1,4 @@
-# Copyright (C) 2021-2022 Huawei Device Co., Ltd.
+# Copyright (C) 2021-2023 Huawei Device Co., Ltd.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -34,6 +34,7 @@ group("test") {
     "unittest/medialibrary_thumbnail_service_test:unittest",
     "unittest/medialibrary_uri_test:unittest",
     "unittest/medialibrary_utils_test:unittest",
+    "unittest/medialibrary_vision_test:unittest",
     "unittest/mediascanner_test:unittest",
     "unittest/notify_test:Notifytest",
     "unittest/photo_album_test:PhotoAlbumTest",

frameworks/innerkitsimpl/test/unittest/medialibrary_vision_test/BUILD.gn

@@ -0,0 +1,56 @@
+# Copyright (C) 2023 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/test.gni")
+import("//foundation/multimedia/media_library/media_library.gni")
+
+group("unittest") {
+  testonly = true
+  deps = [ ":medialibrary_vision_unittest" ]
+}
+
+ohos_unittest("medialibrary_vision_unittest") {
+  module_out_path = "media_library/medialibraryextention"
+  include_dirs = [
+    "./include",
+    "../get_self_permissions/include",
+    "../medialibrary_unittest_utils/include",
+    "${MEDIALIB_INTERFACES_PATH}/inner_api/media_library_helper/include",
+  ]
+
+  sources = [
+    "../get_self_permissions/src/get_self_permissions.cpp",
+    "./src/medialibrary_vision_test.cpp",
+  ]
+  deps = [
+    "${MEDIALIB_INNERKITS_PATH}/media_library_helper:media_library",
+    "${MEDIALIB_INNERKITS_PATH}/medialibrary_data_extension:medialibrary_data_extension",
+  ]
+
+  external_deps = [
+    "ability_base:zuri",
+    "ability_runtime:ability_context_native",
+    "ability_runtime:ability_manager",
+    "ability_runtime:abilitykit_native",
+    "ability_runtime:app_context",
+    "ability_runtime:runtime",
+    "access_token:libaccesstoken_sdk",
+    "access_token:libnativetoken",
+    "access_token:libtoken_setproc",
+    "c_utils:utils",
+    "data_share:datashare_consumer",
+    "hilog:libhilog",
+    "safwk:system_ability_fwk",
+    "samgr:samgr_proxy",
+  ]
+}

frameworks/innerkitsimpl/test/unittest/medialibrary_vision_test/include/medialibrary_vision_test.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MEDIALIBRARY_VISION_TEST_H
+#define MEDIALIBRARY_VISION_TEST_H
+
+#include <gtest/gtest.h>
+
+namespace OHOS {
+namespace Media {
+class MediaLibraryVisionTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+} // namespace Media
+} // namespace OHOS
+#endif // MEDIALIBRARY_VISION_TEST_H

frameworks/innerkitsimpl/test/unittest/medialibrary_vision_test/src/medialibrary_vision_test.cpp

@@ -0,0 +1,398 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define MLOG_TAG "MediaLibraryVisionTest"
+
+#include <stdlib.h>
+
+#include "datashare_helper.h"
+#include "get_self_permissions.h"
+#include "iservice_registry.h"
+#include "media_log.h"
+#include "medialibrary_vision_test.h"
+#include "uri.h"
+#include "vision_column.h"
+
+using namespace std;
+using namespace testing::ext;
+
+namespace OHOS {
+namespace Media {
+using namespace std;
+using namespace testing::ext;
+
+constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
+constexpr int N = 9999;
+std::shared_ptr<DataShare::DataShareHelper> g_dataShareHelper;
+
+std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId)
+{
+    MEDIA_INFO_LOG("CreateDataShareHelper start");
+    auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (saManager == nullptr) {
+        MEDIA_INFO_LOG("GetSystemAbilityManager get samgr failed.");
+        return nullptr;
+    }
+    auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
+    while (remoteObj == nullptr) {
+        MEDIA_INFO_LOG("GetSystemAbility service failed.");
+        return nullptr;
+    }
+    return DataShare::DataShareHelper::Creator(remoteObj, MEDIALIBRARY_DATA_URI);
+}
+
+void CleanVisionData() {
+    DataShare::DataSharePredicates predicates;
+    Uri ocrUri(URI_OCR);
+    Uri labelUri(URI_LABEL);
+    Uri aesUri(URI_AESTHETICS);
+    Uri shieldUri(URI_SHIELD);
+    g_dataShareHelper->Delete(ocrUri, predicates);
+    g_dataShareHelper->Delete(labelUri, predicates);
+    g_dataShareHelper->Delete(aesUri, predicates);
+    g_dataShareHelper->Delete(shieldUri, predicates);
+}
+
+int GetRand(int min, int max) {
+    return rand() % (max - min + 1) + min;
+}
+
+float GetRandFloat(int min, int max) {
+    float num = rand() % (N + 1) / (float)(N + 1);
+	return num * (max - min) + min;
+}
+
+void InitPerformanceData() {
+    Uri ocrUri(URI_OCR);
+    Uri labelUri(URI_LABEL);
+    Uri aesUri(URI_AESTHETICS);
+    for (int i = 0; i <= 10000; i++) {
+        DataShare::DataShareValuesBucket valuesBucket1;
+        valuesBucket1.Put(FILE_ID, i);
+        valuesBucket1.Put(OCR_TEXT, "ocrTest");
+        valuesBucket1.Put(OCR_VERSION, "1.01");
+        valuesBucket1.Put(OCR_TEXT_MSG, "ocrTestMsg");
+        g_dataShareHelper->Insert(ocrUri, valuesBucket1);
+        DataShare::DataShareValuesBucket valuesBucket2;
+        valuesBucket2.Put(FILE_ID, i);
+        valuesBucket2.Put(CATEGORY_ID, GetRand(0, 10));
+        valuesBucket2.Put(SUB_LABEL, GetRand(0, 200));
+        valuesBucket2.Put(PROB, GetRandFloat(0, 10));
+        valuesBucket2.Put(LABEL_VERSION, "1.01");
+        g_dataShareHelper->Insert(labelUri, valuesBucket2);
+        DataShare::DataShareValuesBucket valuesBucket3;
+        valuesBucket3.Put(FILE_ID, i);
+        valuesBucket3.Put(AESTHETICS_SCORE, GetRand(0, 10));
+        valuesBucket3.Put(AESTHETICS_VERSION, "1.01");
+        valuesBucket3.Put(PROB, GetRandFloat(0, 10));
+        g_dataShareHelper->Insert(aesUri, valuesBucket3);
+    }
+}
+
+void MediaLibraryVisionTest::SetUpTestCase(void)
+{
+    MEDIA_INFO_LOG("Vision_Test::Start");
+    g_dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
+    vector<string> perms;
+    perms.push_back("ohos.permission.READ_MEDIA");
+    perms.push_back("ohos.permission.WRITE_MEDIA");
+    uint64_t tokenId = 0;
+    PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryQueryPerfUnitTest", perms, tokenId);
+    ASSERT_TRUE(tokenId != 0);
+}
+
+void MediaLibraryVisionTest::TearDownTestCase(void) {
+    CleanVisionData();
+    MEDIA_INFO_LOG("Vision_Test::End");
+}
+
+void MediaLibraryVisionTest::SetUp(void) {}
+
+void MediaLibraryVisionTest::TearDown(void) {}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_InsertOcr_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_InsertOcr_Test_001::Start");
+    Uri ocrUri(URI_OCR);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(OCR_TEXT, "inserttest");
+    valuesBucket.Put(OCR_VERSION, "1.01");
+    valuesBucket.Put(OCR_TEXT_MSG, "testmsg");
+    auto retVal = g_dataShareHelper->Insert(ocrUri, valuesBucket);
+    EXPECT_EQ((retVal > 0), true);
+    MEDIA_INFO_LOG("Vision_InsertOcr_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_InsertOcr_Test_002, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_InsertOcr_Test_002::Start");
+    Uri ocrUri(URI_OCR);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 11111);
+    valuesBucket.Put(OCR_TEXT, "inserttest");
+    valuesBucket.Put(OCR_VERSION, "1.01");
+    valuesBucket.Put(OCR_TEXT_MSG, "testmsg");
+    auto retVal = g_dataShareHelper->Insert(ocrUri, valuesBucket);
+    auto retVal2 = g_dataShareHelper->Insert(ocrUri, valuesBucket);
+    EXPECT_EQ((retVal > 0 && retVal2 < 0), true);
+    MEDIA_INFO_LOG("Vision_InsertOcr_Test_002::retVal = %{public}d. retVal2 = %{public}d. End", retVal, retVal2);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_UpdateOcr_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_UpdateOcr_Test_001::Start");
+    Uri ocrUri(URI_OCR);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 11112);
+    valuesBucket.Put(OCR_TEXT, "updatetest");
+    valuesBucket.Put(OCR_VERSION, "1.01");
+    valuesBucket.Put(OCR_TEXT_MSG, "testmsg");
+    g_dataShareHelper->Insert(ocrUri, valuesBucket);
+    DataShare::DataShareValuesBucket updateValues;
+    updateValues.Put(OCR_TEXT, "updatetestend");
+    updateValues.Put(OCR_VERSION, "2.01");
+    DataShare::DataSharePredicates predicates;
+    vector<string> inValues;
+    inValues.push_back("11112");
+    inValues.push_back("21233");
+    predicates.In(FILE_ID, inValues);
+    predicates.And();
+    predicates.EqualTo(OCR_TEXT_MSG, "testmsg");
+    auto retVal = g_dataShareHelper->Update(ocrUri, predicates, updateValues);
+    vector<string> columns;
+    columns.push_back(OCR_TEXT);
+    columns.push_back(OCR_VERSION);
+    auto resultSet = g_dataShareHelper->Query(ocrUri, predicates, columns);
+    resultSet->GoToFirstRow();
+    string ocrTest;
+    string ocrVersion;
+    resultSet->GetString(0, ocrTest);
+    resultSet->GetString(1, ocrVersion);
+    EXPECT_NE((resultSet == nullptr), true);
+    EXPECT_EQ((retVal == 1), true);
+    MEDIA_INFO_LOG("Vision_UpdateOcr_Test_001::ocrTest = %{public}s. End", ocrTest.c_str());
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_DeleteOcr_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_DeleteOcr_Test_001::Start");
+    Uri ocrUri(URI_OCR);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 11113);
+    valuesBucket.Put(OCR_TEXT, "deletetest");
+    valuesBucket.Put(OCR_VERSION, "1.01");
+    valuesBucket.Put(OCR_TEXT_MSG, "testmsg");
+    g_dataShareHelper->Insert(ocrUri, valuesBucket);
+    DataShare::DataSharePredicates predicates;
+    vector<string> inValues;
+    inValues.push_back("11113");
+    inValues.push_back("21233");
+    predicates.In(FILE_ID, inValues);
+    predicates.And();
+    predicates.EqualTo(OCR_VERSION, "1.01");
+    auto retVal = g_dataShareHelper->Delete(ocrUri, predicates);
+    EXPECT_EQ((retVal == 1), true);
+    MEDIA_INFO_LOG("Vision_DeleteOcr_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_InsertLabel_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_InsertLabel_Test_001::Start");
+    Uri labelUri(URI_LABEL);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 1);
+    valuesBucket.Put(CATEGORY_ID, 1);
+    valuesBucket.Put(SUB_LABEL, 1);
+    valuesBucket.Put(PROB, 2.344);
+    valuesBucket.Put(LABEL_VERSION, 1);
+    auto retVal = g_dataShareHelper->Insert(labelUri, valuesBucket);
+    EXPECT_EQ((retVal > 0), true);
+    MEDIA_INFO_LOG("Vision_InsertLabel_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_InsertLabel_Test_002, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_InsertLabel_Test_002::Start");
+    Uri labelUri(URI_LABEL);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 2);
+    valuesBucket.Put(CATEGORY_ID, 1);
+    valuesBucket.Put(SUB_LABEL, 1);
+    valuesBucket.Put(PROB, 2.344);
+    valuesBucket.Put(LABEL_VERSION, "1.01");
+    auto retVal = g_dataShareHelper->Insert(labelUri, valuesBucket);
+    DataShare::DataShareValuesBucket valuesBucket2;
+    valuesBucket2.Put(FILE_ID, 2);
+    valuesBucket2.Put(CATEGORY_ID, 1);
+    valuesBucket2.Put(SUB_LABEL, 2);
+    valuesBucket2.Put(PROB, 2.344);
+    valuesBucket2.Put(LABEL_VERSION, "1.01");
+    auto retVal2 = g_dataShareHelper->Insert(labelUri, valuesBucket2);
+    EXPECT_EQ((retVal > 0 && retVal2 > 0), true);
+    MEDIA_INFO_LOG("Vision_InsertLabel_Test_002::retVal = %{public}d. retVal2 = %{public}d. End", retVal, retVal2);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_UpdateLabel_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_UpdateLabel_Test_001::Start");
+    Uri labelUri(URI_LABEL);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 3);
+    valuesBucket.Put(CATEGORY_ID, 1);
+    valuesBucket.Put(SUB_LABEL, 1);
+    valuesBucket.Put(PROB, 2.344);
+    valuesBucket.Put(LABEL_VERSION, "1.01");
+    g_dataShareHelper->Insert(labelUri, valuesBucket);
+    DataShare::DataShareValuesBucket updateValues;
+    updateValues.Put(SUB_LABEL, 3);
+    updateValues.Put(LABEL_VERSION, "2.01");
+    DataShare::DataSharePredicates predicates;
+    vector<string> inValues;
+    inValues.push_back("123421");
+    inValues.push_back("3");
+    predicates.In(FILE_ID, inValues);
+    auto retVal = g_dataShareHelper->Update(labelUri, predicates, updateValues);
+    EXPECT_EQ((retVal == 1), true);
+    MEDIA_INFO_LOG("Vision_UpdateLabel_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_DeleteLabel_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_DeleteLabel_Test_001::Start");
+    Uri labelUri(URI_LABEL);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 4);
+    valuesBucket.Put(CATEGORY_ID, 1);
+    valuesBucket.Put(SUB_LABEL, 1);
+    valuesBucket.Put(PROB, 2.344);
+    valuesBucket.Put(LABEL_VERSION, "1.01");
+    g_dataShareHelper->Insert(labelUri, valuesBucket);
+    valuesBucket.Put(SUB_LABEL, 2);
+    g_dataShareHelper->Insert(labelUri, valuesBucket);
+    valuesBucket.Put(SUB_LABEL, 3);
+    g_dataShareHelper->Insert(labelUri, valuesBucket);
+    DataShare::DataSharePredicates predicates;
+    predicates.EqualTo(FILE_ID, 4);
+    auto retVal = g_dataShareHelper->Delete(labelUri, predicates);
+    EXPECT_EQ((retVal == 3), true);
+    MEDIA_INFO_LOG("Vision_DeleteLabel_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_InsertAes_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_InsertAes_Test_001::Start");
+    Uri aesUri(URI_AESTHETICS);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 1);
+    valuesBucket.Put(AESTHETICS_SCORE, 1);
+    valuesBucket.Put(AESTHETICS_VERSION, "1.01");
+    valuesBucket.Put(PROB, 2.344);
+    auto retVal = g_dataShareHelper->Insert(aesUri, valuesBucket);
+    EXPECT_EQ((retVal > 0), true);
+    MEDIA_INFO_LOG("Vision_InsertAes_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_InsertAes_Test_002, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_InsertAes_Test_002::Start");
+    Uri aesUri(URI_AESTHETICS);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 2);
+    valuesBucket.Put(AESTHETICS_SCORE, 6);
+    valuesBucket.Put(AESTHETICS_VERSION, "1.01");
+    valuesBucket.Put(PROB, 2.344);
+    auto retVal = g_dataShareHelper->Insert(aesUri, valuesBucket);
+    DataShare::DataShareValuesBucket valuesBucket2;
+    valuesBucket2.Put(FILE_ID, 2);
+    valuesBucket.Put(AESTHETICS_SCORE, 6);
+    valuesBucket.Put(AESTHETICS_VERSION, "1.01");
+    valuesBucket.Put(PROB, 2.344);
+    auto retVal2 = g_dataShareHelper->Insert(aesUri, valuesBucket2);
+    EXPECT_EQ((retVal > 0 && retVal2 < 0), true);
+    MEDIA_INFO_LOG("Vision_InsertAes_Test_002::retVal = %{public}d. retVal2 = %{public}d. End", retVal, retVal2);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_UpdateAes_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_UpdateAes_Test_001::Start");
+    Uri aesUri(URI_AESTHETICS);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 3);
+    valuesBucket.Put(AESTHETICS_SCORE, 6);
+    valuesBucket.Put(AESTHETICS_VERSION, "1.01");
+    valuesBucket.Put(PROB, 2.344);
+    g_dataShareHelper->Insert(aesUri, valuesBucket);
+    DataShare::DataShareValuesBucket updateValues;
+    updateValues.Put(AESTHETICS_SCORE, 8);
+    updateValues.Put(AESTHETICS_VERSION, "2.01");
+    DataShare::DataSharePredicates predicates;
+    vector<string> inValues;
+    inValues.push_back("3");
+    predicates.In(FILE_ID, inValues);
+    auto retVal = g_dataShareHelper->Update(aesUri, predicates, updateValues);
+    EXPECT_EQ((retVal == 1), true);
+    MEDIA_INFO_LOG("Vision_UpdateAes_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_DeleteAes_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_DeleteAes_Test_001::Start");
+    Uri aesUri(URI_AESTHETICS);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(FILE_ID, 4);
+    valuesBucket.Put(AESTHETICS_SCORE, 6);
+    valuesBucket.Put(AESTHETICS_VERSION, "1.01");
+    valuesBucket.Put(PROB, 2.344);
+    g_dataShareHelper->Insert(aesUri, valuesBucket);
+    DataShare::DataSharePredicates predicates;
+    predicates.EqualTo(FILE_ID, 4);
+    auto retVal = g_dataShareHelper->Delete(aesUri, predicates);
+    EXPECT_EQ((retVal == 1), true);
+    MEDIA_INFO_LOG("Vision_DeleteAes_Test_001::retVal = %{public}d. End", retVal);
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_Shield_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_Shield_Test_001::Start");
+    Uri shieldUri(URI_SHIELD);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put(SHIELD_KEY, "testkey1");
+    valuesBucket.Put(SHIELD_VALUE, "testValue1");
+    g_dataShareHelper->Insert(shieldUri, valuesBucket);
+    valuesBucket.Put(SHIELD_KEY, "testkey2");
+    valuesBucket.Put(SHIELD_VALUE, "testValue2");
+    g_dataShareHelper->Insert(shieldUri, valuesBucket);
+    DataShare::DataSharePredicates predicates;
+    predicates.EqualTo(SHIELD_KEY, "testkey2");
+    vector<string> columns;
+    columns.push_back(SHIELD_KEY);
+    columns.push_back(SHIELD_VALUE);
+    auto resultSet = g_dataShareHelper->Query(shieldUri, predicates, columns);
+    resultSet->GoToFirstRow();
+    string key;
+    string value;
+    resultSet->GetString(0, key);
+    resultSet->GetString(1, value);
+    EXPECT_NE((resultSet == nullptr), true);
+    MEDIA_INFO_LOG("Vision_Shield_Test_001::key = %{public}s, value = %{public}s End", key.c_str(), value.c_str());
+}
+
+HWTEST_F(MediaLibraryVisionTest, Vision_Performence_Test_001, TestSize.Level0)
+{
+    MEDIA_INFO_LOG("Vision_Performence_Test_001::Start");
+    CleanVisionData();
+    InitPerformanceData();
+}
+} // namespace Media
+} // namespace OHOS

interfaces/inner_api/media_library_helper/include/medialibrary_db_const.h

@@ -22,7 +22,7 @@
 
 namespace OHOS {
 namespace Media {
-const int32_t MEDIA_RDB_VERSION = 17;
+const int32_t MEDIA_RDB_VERSION = 18;
 enum {
     VERSION_ADD_CLOUD = 2,
     VERSION_ADD_META_MODIFED = 3,
@@ -45,6 +45,7 @@ enum {
     VERSION_ADD_ALL_EXIF = 15,
     VERSION_ADD_UPDATE_CLOUD_SYNC_TRIGGER = 16,
     VERSION_ADD_YEAR_MONTH_DAY = 17,
+    VERSION_ADD_VISION_TABLE = 18,
 };
 
 enum {

interfaces/inner_api/media_library_helper/include/vision_column.h

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MEDIALIBRARY_VISION_COLUMN_H
+#define MEDIALIBRARY_VISION_COLUMN_H
+
+#include "media_column.h"
+#include "userfilemgr_uri.h"
+
+namespace OHOS {
+namespace Media {
+
+// table name
+const std::string VISION_OCR_TABLE = "tab_analysis_ocr";
+const std::string VISION_LABEL_TABLE = "tab_analysis_label";
+const std::string VISION_AESTHETICS_TABLE = "tab_analysis_aesthetics_score";
+const std::string VISION_TOTAL_TABLE = "tab_analysis_total";
+const std::string VISION_SHIELD_TABLE = "tab_application_shield";
+
+// create vision table
+const std::string ID = "id";
+const std::string FILE_ID = "file_id";
+const std::string OCR_TEXT = "ocr_text";
+const std::string OCR_VERSION = "ocr_version";
+const std::string OCR_TEXT_MSG = "ocr_text_msg";
+const std::string CREATE_TAB_ANALYSIS_OCR = "CREATE TABLE IF NOT EXISTS " + VISION_OCR_TABLE + " (" +
+    ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
+    FILE_ID + " INT UNIQUE, " +
+    OCR_TEXT + " TEXT, " +  
+    OCR_VERSION + " TEXT, " +
+    OCR_TEXT_MSG + " TEXT) ";
+
+const std::string CATEGORY_ID = "category_id";
+const std::string SUB_LABEL = "sub_label";
+const std::string PROB = "prob";
+const std::string LABEL_VERSION = "label_version";
+const std::string CREATE_TAB_ANALYSIS_LABEL = "CREATE TABLE IF NOT EXISTS " + VISION_LABEL_TABLE + " (" +
+    ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
+    FILE_ID + " INT, " +
+    CATEGORY_ID + " INT, " +
+    SUB_LABEL + " INT, " +
+    PROB + " REAL, " +
+    LABEL_VERSION + " TEXT) ";
+
+const std::string AESTHETICS_SCORE = "aesthetics_score";
+const std::string AESTHETICS_VERSION = "aesthetics_version";
+const std::string CREATE_TAB_ANALYSIS_AESTHETICS = "CREATE TABLE IF NOT EXISTS " + VISION_AESTHETICS_TABLE + " (" +
+    ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
+    FILE_ID + " INT UNIQUE, " +
+    AESTHETICS_SCORE + " INT, " +
+    AESTHETICS_VERSION + " TEXT, " +
+    PROB + " REAL) ";                 
+
+const std::string STATUS = "status";
+const std::string OCR = "ocr";
+const std::string LABEL = "label";
+const std::string CREATE_TAB_ANALYSIS_TOTAL = "CREATE TABLE IF NOT EXISTS " + VISION_TOTAL_TABLE + " (" +
+    ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
+    FILE_ID + " INT UNIQUE, " +
+    STATUS + " INT, " +
+    OCR + " INT, " +
+    LABEL + " INT, " +
+    AESTHETICS_SCORE + " INT) ";
+
+const std::string SHIELD_KEY = "shield_key";
+const std::string SHIELD_VALUE = "shield_value";
+const std::string CREATE_TAB_APPLICATION_SHIELD = "CREATE TABLE IF NOT EXISTS " + VISION_SHIELD_TABLE + " (" +
+    ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
+    SHIELD_KEY + " TEXT, " +
+    SHIELD_VALUE + " TEXT) ";
+
+const std::string INIT_TAB_ANALYSIS_TOTAL = "INSERT INTO " + VISION_TOTAL_TABLE + " (" +
+    FILE_ID + ", " + STATUS + ", " + OCR + ", " + AESTHETICS_SCORE + ", " + LABEL + ") " +
+    "SELECT " + FILE_ID +
+    ", CASE WHEN date_trashed > 0 THEN 2 ELSE 0 END," +
+    " 0," +
+    " CASE WHEN subtype = 1 THEN -1 ELSE 0 END," +
+    " CASE WHEN subtype = 1 THEN -1 ELSE 0 END" +
+    " FROM " + PhotoColumn::PHOTOS_TABLE + " WHERE MEDIA_TYPE = 1";
+
+// trigger
+const std::string CREATE_VISION_DELETE_TRIGGER = "CREATE TRIGGER IF NOT EXISTS delete_vision_trigger AFTER DELETE ON " +
+    PhotoColumn::PHOTOS_TABLE + " FOR EACH ROW " +
+    " BEGIN " +
+    " UPDATE " + VISION_TOTAL_TABLE +
+    " SET " + STATUS + " = -1 " +
+    " WHERE " + FILE_ID +
+    " = OLD.file_id;" +
+    " END;";
+
+const std::string CREATE_VISION_UPDATE_TRIGGER = "CREATE TRIGGER IF NOT EXISTS update_vision_trigger AFTER UPDATE ON " +
+    PhotoColumn::PHOTOS_TABLE + " FOR EACH ROW " +
+    " WHEN ((NEW.date_trashed > 0 AND OLD.date_trashed = 0)" +
+    " OR (NEW.date_trashed = 0 AND OLD.date_trashed > 0))" +
+    " AND NEW.MEDIA_TYPE = 1" +
+    " BEGIN " +
+    " UPDATE " + VISION_TOTAL_TABLE +
+    " SET " + STATUS + " = " +
+    " (CASE WHEN NEW.date_trashed > 0 THEN 2 ELSE 0 END)" +
+    " WHERE file_id = OLD.file_id;" +
+    " END;";
+
+const std::string CREATE_VISION_INSERT_TRIGGER = "CREATE TRIGGER IF NOT EXISTS insert_vision_trigger AFTER INSERT ON " +
+    PhotoColumn::PHOTOS_TABLE + " FOR EACH ROW " +
+    " WHEN NEW.MEDIA_TYPE = 1" +
+    " BEGIN " +
+    " INSERT INTO " + VISION_TOTAL_TABLE +
+    " (" + FILE_ID + ", " + STATUS + ", " + OCR + ", " +
+    AESTHETICS_SCORE + ", " + LABEL + ")" +
+    " VALUES (" +
+    " NEW.file_id, 0, 0," +
+    " (CASE WHEN NEW.subtype = 1 THEN -1 ELSE 0 END)," +
+    " (CASE WHEN NEW.subtype = 1 THEN -1 ELSE 0 END));" +
+    " END;";
+
+const std::string URI_OCR = MEDIALIBRARY_DATA_URI + "/" + VISION_OCR_TABLE;
+const std::string URI_LABEL = MEDIALIBRARY_DATA_URI + "/" + VISION_LABEL_TABLE;
+const std::string URI_AESTHETICS = MEDIALIBRARY_DATA_URI + "/" + VISION_AESTHETICS_TABLE;
+const std::string URI_TOTAL = MEDIALIBRARY_DATA_URI + "/" + VISION_TOTAL_TABLE;
+const std::string URI_SHIELD = MEDIALIBRARY_DATA_URI + "/" + VISION_SHIELD_TABLE;
+} // namespace Media
+} // namespace OHOS
+#endif // MEDIALIBRARY_VISION_COLUMN_H