1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "photo_album_column.h"
17 
18 #include <string>
19 #include "location_column.h"
20 #include "media_column.h"
21 #include "media_log.h"
22 #include "medialibrary_type_const.h"
23 #include "photo_map_column.h"
24 #include "vision_column.h"
25 #include "vision_face_tag_column.h"
26 
27 namespace OHOS::Media {
28 using namespace std;
29 using namespace NativeRdb;
30 
31 // PhotoAlbum table
32 const string PhotoAlbumColumns::TABLE = "PhotoAlbum";
33 const string PhotoAlbumColumns::ALBUM_ID = "album_id";
34 const string PhotoAlbumColumns::ALBUM_TYPE = "album_type";
35 const string PhotoAlbumColumns::ALBUM_SUBTYPE = "album_subtype";
36 const string PhotoAlbumColumns::ALBUM_NAME = "album_name";
37 const string PhotoAlbumColumns::ALBUM_COVER_URI = "cover_uri";
38 const string PhotoAlbumColumns::ALBUM_COUNT = "count";
39 const string PhotoAlbumColumns::ALBUM_DATE_MODIFIED = "date_modified";
40 const string PhotoAlbumColumns::ALBUM_DIRTY = "dirty";
41 const string PhotoAlbumColumns::ALBUM_CLOUD_ID = "cloud_id";
42 const string PhotoAlbumColumns::ALBUM_IMAGE_COUNT = "image_count";
43 const string PhotoAlbumColumns::ALBUM_VIDEO_COUNT = "video_count";
44 const string PhotoAlbumColumns::ALBUM_LATITUDE = "latitude";
45 const string PhotoAlbumColumns::ALBUM_LONGITUDE = "longitude";
46 const string PhotoAlbumColumns::ALBUM_BUNDLE_NAME = "bundle_name";
47 const string PhotoAlbumColumns::ALBUM_LOCAL_LANGUAGE = "local_language";
48 const string PhotoAlbumColumns::ALBUM_IS_LOCAL = "is_local";
49 const string PhotoAlbumColumns::ALBUM_DATE_ADDED = "date_added";
50 const string PhotoAlbumColumns::ALBUM_PRIORITY = "priority";
51 const string PhotoAlbumColumns::ALBUM_LPATH = "lpath";
52 
53 // For api9 compatibility
54 const string PhotoAlbumColumns::ALBUM_RELATIVE_PATH = "relative_path";
55 
56 const string PhotoAlbumColumns::CONTAINS_HIDDEN = "contains_hidden";
57 const string PhotoAlbumColumns::HIDDEN_COUNT = "hidden_count";
58 const string PhotoAlbumColumns::HIDDEN_COVER = "hidden_cover";
59 
60 // For sorting albums
61 const string PhotoAlbumColumns::ALBUM_ORDER = "album_order";
62 const string PhotoAlbumColumns::REFERENCE_ALBUM_ID = "reference_album_id";
63 
64 // location album result
65 const std::string LOCATION_ALBUM_ID = MediaColumn::MEDIA_ID + " AS " + ALBUM_ID;
66 const std::string LOCATION_ALBUM_TYPE = std::to_string(PhotoAlbumType::SMART) + " AS " + ALBUM_TYPE;
67 const std::string LOCATION_ALBUM_SUBTYPE = std::to_string(PhotoAlbumSubType::GEOGRAPHY_LOCATION) +
68     " AS " + ALBUM_SUBTYPE;
69 const std::string LOCATION_COUNT = "COUNT(*) AS " + COUNT;
70 const std::string LOCATION_DATE_MODIFIED = "MAX(" + MediaColumn::MEDIA_DATE_ADDED + ") AS " + DATE_MODIFIED;
71 const std::string CITY_ALBUM_NAME =  CITY_NAME + " AS " + ALBUM_NAME;
72 const std::string LOCATION_COVER_URI =
73     " (SELECT '" + PhotoColumn::PHOTO_URI_PREFIX + "'||" + MediaColumn::MEDIA_ID + "||" +
74     "(SELECT SUBSTR(" + MediaColumn::MEDIA_FILE_PATH +
75     ", (SELECT LENGTH(" + MediaColumn::MEDIA_FILE_PATH +
76     ") - INSTR(reverseStr, '/') + 1) , (SELECT (SELECT LENGTH(" +
77     MediaColumn::MEDIA_FILE_PATH + ") - INSTR(reverseStr, '.')) - (SELECT LENGTH(" +
78     MediaColumn::MEDIA_FILE_PATH + ") - INSTR(reverseStr, '/')))) from (select " +
79     " (WITH RECURSIVE reverse_string(str, revstr) AS ( SELECT " +
80     MediaColumn::MEDIA_FILE_PATH + ", '' UNION ALL SELECT SUBSTR(str, 1, LENGTH(str) - 1), " +
81     "revstr || SUBSTR(str, LENGTH(str), 1) FROM reverse_string WHERE LENGTH(str) > 1 ) " +
82     " SELECT revstr || str FROM reverse_string WHERE LENGTH(str) = 1) as reverseStr)) ||'/'||" +
83     MediaColumn::MEDIA_NAME + ") AS " + COVER_URI;
84 
85 // default fetch columns
86 const set<string> PhotoAlbumColumns::DEFAULT_FETCH_COLUMNS = {
87     ALBUM_ID, ALBUM_TYPE, ALBUM_SUBTYPE, ALBUM_NAME, ALBUM_COVER_URI, ALBUM_COUNT, ALBUM_DATE_MODIFIED
88 };
89 
90 // location default fetch columns
91 const vector<string> PhotoAlbumColumns::LOCATION_DEFAULT_FETCH_COLUMNS = {
92     LATITUDE, LONGITUDE, LOCATION_ALBUM_TYPE, LOCATION_ALBUM_SUBTYPE, LOCATION_COUNT,
93     LOCATION_DATE_MODIFIED, LOCATION_COVER_URI, LOCATION_ALBUM_ID
94 };
95 
96 // city default fetch columns
97 const vector<string> PhotoAlbumColumns::CITY_DEFAULT_FETCH_COLUMNS = {
98     ALBUM_ID, ALBUM_TYPE, ALBUM_SUBTYPE, CITY_ALBUM_NAME, ALBUM_COVER_URI, ALBUM_COUNT, ALBUM_DATE_MODIFIED
99 };
100 
101 const string PhotoAlbumColumns::ALBUM_URI_PREFIX = "file://media/PhotoAlbum/";
102 const string PhotoAlbumColumns::DEFAULT_PHOTO_ALBUM_URI = "file://media/PhotoAlbum";
103 const string PhotoAlbumColumns::HIDDEN_ALBUM_URI_PREFIX = "file://media/HiddenAlbum/";
104 const string PhotoAlbumColumns::DEFAULT_HIDDEN_ALBUM_URI = "file://media/HiddenAlbum";
105 const string PhotoAlbumColumns::ANALYSIS_ALBUM_URI_PREFIX = "file://media/AnalysisAlbum/";
106 
107 const string PhotoAlbumColumns::ALBUM_CLOUD_URI_PREFIX = "file://cloudsync/PhotoAlbum/";
108 
109 // Create tables
110 const string PhotoAlbumColumns::CREATE_TABLE = CreateTable() +
111     TABLE + " (" +
112     ALBUM_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
113     ALBUM_TYPE + " INT, " +
114     ALBUM_SUBTYPE + " INT, " +
115     ALBUM_NAME + " TEXT COLLATE NOCASE, " +
116     ALBUM_COVER_URI + " TEXT, " +
117     ALBUM_COUNT + " INT DEFAULT 0, " +
118     ALBUM_DATE_MODIFIED + " BIGINT DEFAULT 0, " +
119     ALBUM_DIRTY + " INT DEFAULT " + std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_NEW)) + ", " +
120     ALBUM_CLOUD_ID + " TEXT, " +
121     ALBUM_RELATIVE_PATH + " TEXT, " +
122     CONTAINS_HIDDEN + " INT DEFAULT 0, " +
123     HIDDEN_COUNT + " INT DEFAULT 0, " +
124     HIDDEN_COVER + " TEXT DEFAULT '', " +
125     ALBUM_ORDER + " INT," +
126     ALBUM_IMAGE_COUNT + " INT DEFAULT 0, " +
127     ALBUM_VIDEO_COUNT + " INT DEFAULT 0, " +
128     ALBUM_BUNDLE_NAME + " TEXT, " +
129     ALBUM_LOCAL_LANGUAGE + " TEXT, " +
130     ALBUM_IS_LOCAL + " INT, " +
131     ALBUM_DATE_ADDED + " BIGINT DEFAULT 0, " +
132     ALBUM_LPATH + " TEXT, " +
133     ALBUM_PRIORITY + " INT)";
134 
135 // Create indexes
136 const string PhotoAlbumColumns::INDEX_ALBUM_TYPES = CreateIndex() + "photo_album_types" + " ON " + TABLE +
137     " (" + ALBUM_TYPE + "," + ALBUM_SUBTYPE + ");";
138 
139 // Create triggers
140 const std::string PhotoAlbumColumns::CREATE_ALBUM_INSERT_TRIGGER =
141     " CREATE TRIGGER IF NOT EXISTS album_insert_cloud_sync_trigger AFTER INSERT ON " + TABLE +
142     " BEGIN SELECT cloud_sync_func(); END;";
143 
144 const std::string PhotoAlbumColumns::CREATE_ALBUM_DELETE_TRIGGER =
145     "CREATE TRIGGER IF NOT EXISTS album_delete_trigger AFTER UPDATE ON " + TABLE +
146     " FOR EACH ROW WHEN new." + ALBUM_DIRTY + " = " +
147     std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_DELETED)) +
148     " AND old." + ALBUM_DIRTY + " = " + std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_NEW)) +
149     " AND is_caller_self_func() = 'true' BEGIN DELETE FROM " + TABLE +
150     " WHERE " + ALBUM_ID + " = old." + ALBUM_ID + "; SELECT cloud_sync_func(); END;";
151 
152 const std::string PhotoAlbumColumns::CREATE_ALBUM_MDIRTY_TRIGGER =
153     "CREATE TRIGGER IF NOT EXISTS album_modify_trigger AFTER UPDATE ON " + TABLE +
154     " FOR EACH ROW WHEN old." + ALBUM_DIRTY + " = " +
155     std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_SYNCED)) +
156     " AND old." + ALBUM_DIRTY + " = " + "new." + ALBUM_DIRTY +
157     " AND is_caller_self_func() = 'true'" +
158     " AND " + PhotoAlbumColumns::CheckUploadPhotoAlbumColumns() +
159     " BEGIN UPDATE " + TABLE + " SET dirty = " +
160     std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_MDIRTY)) +
161     " WHERE " + ALBUM_ID + " = old." + ALBUM_ID + "; SELECT cloud_sync_func(); END;";
162 
163 
164 const std::string PhotoAlbumColumns::ALBUM_DELETE_ORDER_TRIGGER =
165         " CREATE TRIGGER IF NOT EXISTS update_order_trigger AFTER DELETE ON " + PhotoAlbumColumns::TABLE +
166         " FOR EACH ROW " +
167         " BEGIN " +
168         " UPDATE " + PhotoAlbumColumns::TABLE + " SET album_order = album_order - 1" +
169         " WHERE album_order > old.album_order; " +
170         " END";
171 
172 const std::string PhotoAlbumColumns::ALBUM_INSERT_ORDER_TRIGGER =
173         " CREATE TRIGGER IF NOT EXISTS insert_order_trigger AFTER INSERT ON " + PhotoAlbumColumns::TABLE +
174         " BEGIN " +
175         " UPDATE " + PhotoAlbumColumns::TABLE + " SET album_order = (" +
176         " SELECT COALESCE(MAX(album_order), 0) + 1 FROM " + PhotoAlbumColumns::TABLE +
177         ") WHERE rowid = new.rowid;" +
178         " END";
179 
IsPhotoAlbumColumn(const string & columnName)180 bool PhotoAlbumColumns::IsPhotoAlbumColumn(const string &columnName)
181 {
182     static const set<string> PHOTO_ALBUM_COLUMNS = {
183         PhotoAlbumColumns::ALBUM_ID, PhotoAlbumColumns::ALBUM_TYPE, PhotoAlbumColumns::ALBUM_SUBTYPE,
184         PhotoAlbumColumns::ALBUM_NAME, PhotoAlbumColumns::ALBUM_COVER_URI, PhotoAlbumColumns::ALBUM_COUNT,
185         PhotoAlbumColumns::ALBUM_RELATIVE_PATH, CONTAINS_HIDDEN, HIDDEN_COUNT, HIDDEN_COVER
186     };
187     return PHOTO_ALBUM_COLUMNS.find(columnName) != PHOTO_ALBUM_COLUMNS.end();
188 }
189 
SetDefaultPredicatesCondition(RdbPredicates & predicates,const int32_t dateTrashed,const bool isHidden,const int32_t timePending,const bool isTemp)190 inline void SetDefaultPredicatesCondition(RdbPredicates &predicates, const int32_t dateTrashed,
191     const bool isHidden, const int32_t timePending, const bool isTemp)
192 {
193     predicates.EqualTo(MediaColumn::MEDIA_DATE_TRASHED, to_string(dateTrashed));
194     predicates.EqualTo(MediaColumn::MEDIA_HIDDEN, to_string(isHidden));
195     predicates.EqualTo(MediaColumn::MEDIA_TIME_PENDING, to_string(timePending));
196     predicates.EqualTo(PhotoColumn::PHOTO_IS_TEMP, to_string(isTemp));
197     predicates.EqualTo(PhotoColumn::PHOTO_BURST_COVER_LEVEL,
198         to_string(static_cast<int32_t>(BurstCoverLevelType::COVER)));
199 }
200 
GetUserAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)201 void PhotoAlbumColumns::GetUserAlbumPredicates(const int32_t albumId, RdbPredicates &predicates, const bool hiddenState)
202 {
203     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
204     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
205     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
206     predicates.EqualTo(PhotoColumn::PHOTO_OWNER_ALBUM_ID, to_string(albumId));
207 }
208 
GetPortraitAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)209 void PhotoAlbumColumns::GetPortraitAlbumPredicates(const int32_t albumId, RdbPredicates &predicates,
210     const bool hiddenState)
211 {
212     string onClause = MediaColumn::MEDIA_ID + " = " + PhotoMap::ASSET_ID;
213     vector<string> clauses = { onClause };
214     predicates.InnerJoin(ANALYSIS_PHOTO_MAP_TABLE)->On(clauses);
215     onClause = ALBUM_ID + " = " + PhotoMap::ALBUM_ID;
216     clauses = { onClause };
217     predicates.InnerJoin(ANALYSIS_ALBUM_TABLE)->On(clauses);
218     string tempTable = "(SELECT " + GROUP_TAG + " FROM " + ANALYSIS_ALBUM_TABLE + " WHERE " + ALBUM_ID + " = " +
219         to_string(albumId) + ") ag";
220     onClause = "ag." + GROUP_TAG + " = " + ANALYSIS_ALBUM_TABLE + "." + GROUP_TAG;
221     clauses = { onClause };
222     predicates.InnerJoin(tempTable)->On(clauses);
223     SetDefaultPredicatesCondition(predicates, 0, 0, 0, false);
224     predicates.Distinct();
225     return;
226 }
227 
GetAnalysisAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)228 void PhotoAlbumColumns::GetAnalysisAlbumPredicates(const int32_t albumId,
229     RdbPredicates &predicates, const bool hiddenState)
230 {
231     string onClause = MediaColumn::MEDIA_ID + " = " + PhotoMap::ASSET_ID;
232     predicates.InnerJoin(ANALYSIS_PHOTO_MAP_TABLE)->On({ onClause });
233     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
234     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
235     predicates.EqualTo(PhotoMap::ALBUM_ID, to_string(albumId));
236 }
237 
GetFavoritePredicates(RdbPredicates & predicates,const bool hiddenState)238 static void GetFavoritePredicates(RdbPredicates &predicates, const bool hiddenState)
239 {
240     predicates.BeginWrap();
241     constexpr int32_t isFavorite = 1;
242     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
243     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
244     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
245     predicates.EqualTo(MediaColumn::MEDIA_IS_FAV, to_string(isFavorite));
246     predicates.EndWrap();
247 }
248 
GetVideoPredicates(RdbPredicates & predicates,const bool hiddenState)249 static void GetVideoPredicates(RdbPredicates &predicates, const bool hiddenState)
250 {
251     predicates.BeginWrap();
252     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
253     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
254     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
255     predicates.EqualTo(MediaColumn::MEDIA_TYPE, to_string(MEDIA_TYPE_VIDEO));
256     predicates.EndWrap();
257 }
258 
GetHiddenPredicates(RdbPredicates & predicates)259 static void GetHiddenPredicates(RdbPredicates &predicates)
260 {
261     predicates.BeginWrap();
262     constexpr int32_t isHidden = 1;
263     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
264     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
265     SetDefaultPredicatesCondition(predicates, 0, isHidden, 0, false);
266     predicates.EndWrap();
267 }
268 
GetTrashPredicates(RdbPredicates & predicates)269 static void GetTrashPredicates(RdbPredicates &predicates)
270 {
271     predicates.BeginWrap();
272     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
273     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
274     predicates.GreaterThan(MediaColumn::MEDIA_DATE_TRASHED, to_string(0));
275     predicates.EqualTo(PhotoColumn::PHOTO_BURST_COVER_LEVEL,
276         to_string(static_cast<int32_t>(BurstCoverLevelType::COVER)));
277     predicates.EndWrap();
278 }
279 
GetScreenshotPredicates(RdbPredicates & predicates,const bool hiddenState)280 static void GetScreenshotPredicates(RdbPredicates &predicates, const bool hiddenState)
281 {
282     predicates.BeginWrap();
283     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
284     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
285     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
286     predicates.EqualTo(PhotoColumn::PHOTO_SUBTYPE, to_string(static_cast<int32_t>(PhotoSubType::SCREENSHOT)));
287     predicates.EndWrap();
288 }
289 
GetCameraPredicates(RdbPredicates & predicates,const bool hiddenState)290 static void GetCameraPredicates(RdbPredicates &predicates, const bool hiddenState)
291 {
292     predicates.BeginWrap();
293     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
294     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
295     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
296     predicates.EqualTo(PhotoColumn::PHOTO_SUBTYPE, to_string(static_cast<int32_t>(PhotoSubType::CAMERA)));
297     predicates.EndWrap();
298 }
299 
GetAllImagesPredicates(RdbPredicates & predicates,const bool hiddenState)300 static void GetAllImagesPredicates(RdbPredicates &predicates, const bool hiddenState)
301 {
302     predicates.BeginWrap();
303     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
304     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
305     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
306     predicates.EqualTo(MediaColumn::MEDIA_TYPE, to_string(MEDIA_TYPE_IMAGE));
307     predicates.EndWrap();
308 }
309 
GetCloudEnhancementPredicates(RdbPredicates & predicates,const bool hiddenState)310 static void GetCloudEnhancementPredicates(RdbPredicates &predicates, const bool hiddenState)
311 {
312     predicates.BeginWrap();
313     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
314     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
315     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
316     predicates.EqualTo(PhotoColumn::PHOTO_STRONG_ASSOCIATION,
317         to_string(static_cast<int32_t>(StrongAssociationType::CLOUD_ENHANCEMENT)));
318     predicates.EqualTo(MediaColumn::MEDIA_TYPE, to_string(MEDIA_TYPE_IMAGE));
319     predicates.EndWrap();
320 }
321 
GetSourceAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)322 void PhotoAlbumColumns::GetSourceAlbumPredicates(const int32_t albumId, RdbPredicates &predicates,
323     const bool hiddenState)
324 {
325     predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
326     predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
327     SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
328     predicates.EqualTo(PhotoColumn::PHOTO_OWNER_ALBUM_ID, to_string(albumId));
329 }
330 
GetSystemAlbumPredicates(const PhotoAlbumSubType subtype,RdbPredicates & predicates,const bool hiddenState)331 void PhotoAlbumColumns::GetSystemAlbumPredicates(const PhotoAlbumSubType subtype, RdbPredicates &predicates,
332     const bool hiddenState)
333 {
334     switch (subtype) {
335         case PhotoAlbumSubType::FAVORITE: {
336             return GetFavoritePredicates(predicates, hiddenState);
337         }
338         case PhotoAlbumSubType::VIDEO: {
339             return GetVideoPredicates(predicates, hiddenState);
340         }
341         case PhotoAlbumSubType::HIDDEN: {
342             return GetHiddenPredicates(predicates);
343         }
344         case PhotoAlbumSubType::TRASH: {
345             return GetTrashPredicates(predicates);
346         }
347         case PhotoAlbumSubType::SCREENSHOT: {
348             return GetScreenshotPredicates(predicates, hiddenState);
349         }
350         case PhotoAlbumSubType::CAMERA: {
351             return GetCameraPredicates(predicates, hiddenState);
352         }
353         case PhotoAlbumSubType::IMAGE: {
354             return GetAllImagesPredicates(predicates, hiddenState);
355         }
356         case PhotoAlbumSubType::CLOUD_ENHANCEMENT: {
357             return GetCloudEnhancementPredicates(predicates, hiddenState);
358         }
359         default: {
360             predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(0));
361             MEDIA_ERR_LOG("Unsupported system album subtype: %{public}d", subtype);
362             return;
363         }
364     }
365 }
366 
CheckUploadPhotoAlbumColumns()367 std::string PhotoAlbumColumns::CheckUploadPhotoAlbumColumns()
368 {
369     // Since date_modified has been checked in mdirty and fdirty, omit it here.
370     const std::vector<std::string> uploadPhotoAlbumColumns = {
371         ALBUM_NAME,
372     };
373 
374     std::string result = "(";
375     size_t size = uploadPhotoAlbumColumns.size();
376     for (size_t i = 0; i < size; i++) {
377         std::string column = uploadPhotoAlbumColumns[i];
378         if (i != size - 1) {
379             result += "new." + column + " <> old." + column + " OR ";
380         } else {
381             result += "new." + column + " <> old." + column + ")";
382         }
383     }
384     return result;
385 }
386 } // namespace OHOS::Media
387