1 /*
2  * Copyright (C) 2024 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 <sys/stat.h>
17 #include "dfx_database_utils.h"
18 
19 #include "dfx_utils.h"
20 #include "medialibrary_rdbstore.h"
21 #include "medialibrary_unistore_manager.h"
22 #include "media_log.h"
23 #include "media_column.h"
24 #include "medialibrary_errno.h"
25 #include "result_set_utils.h"
26 #include "photo_album_column.h"
27 #include "userfile_manager_types.h"
28 
29 namespace OHOS {
30 namespace Media {
31 const std::string RECORD_COUNT = "recordCount";
32 const std::string ABNORMAL_VALUE = "-1";
33 
QueryFromPhotos(int32_t mediaType,int32_t position)34 int32_t DfxDatabaseUtils::QueryFromPhotos(int32_t mediaType, int32_t position)
35 {
36     NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
37     predicates.EqualTo(MediaColumn::MEDIA_TYPE, mediaType);
38     predicates.EqualTo(PhotoColumn::PHOTO_POSITION, position);
39 
40     std::vector<std::string> columns = { "count(1) AS count" };
41     std::string queryColumn = "count";
42 
43     int32_t count;
44     int32_t errCode = QueryInt(predicates, columns, queryColumn, count);
45     if (errCode != E_OK) {
46         MEDIA_ERR_LOG("query photos fail: %{public}d mediaType: %{public}d position: %{public}d",
47             errCode, mediaType, position);
48     }
49 
50     return count;
51 }
52 
QueryAlbumInfoBySubtype(int32_t albumSubtype)53 AlbumInfo DfxDatabaseUtils::QueryAlbumInfoBySubtype(int32_t albumSubtype)
54 {
55     AlbumInfo albumInfo;
56     NativeRdb::RdbPredicates predicates(PhotoAlbumColumns::TABLE);
57     predicates.EqualTo(PhotoAlbumColumns::ALBUM_SUBTYPE, albumSubtype);
58     std::vector<std::string> columns = { PhotoAlbumColumns::ALBUM_COUNT, PhotoAlbumColumns::ALBUM_IMAGE_COUNT,
59         PhotoAlbumColumns::ALBUM_VIDEO_COUNT, PhotoAlbumColumns::ALBUM_CLOUD_ID };
60     auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
61     if (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK) {
62         MEDIA_ERR_LOG("query album fail");
63         return albumInfo;
64     }
65     albumInfo.count = GetInt32Val(PhotoAlbumColumns::ALBUM_COUNT, resultSet);
66     albumInfo.imageCount = GetInt32Val(PhotoAlbumColumns::ALBUM_IMAGE_COUNT, resultSet);
67     albumInfo.videoCount = GetInt32Val(PhotoAlbumColumns::ALBUM_VIDEO_COUNT, resultSet);
68     albumInfo.isLocal = GetStringVal(PhotoAlbumColumns::ALBUM_CLOUD_ID, resultSet) == "" ? true : false;
69     return albumInfo;
70 }
71 
QueryDirtyCloudPhoto()72 std::vector<PhotoInfo> DfxDatabaseUtils::QueryDirtyCloudPhoto()
73 {
74     vector<PhotoInfo> photoInfoList;
75     NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
76     predicates.IsNotNull(PhotoColumn::PHOTO_CLOUD_ID);
77     predicates.NotEqualTo(PhotoColumn::PHOTO_DIRTY, static_cast<int32_t> (DirtyType::TYPE_SYNCED));
78     predicates.Limit(DIRTY_PHOTO_COUNT);
79     std::vector<std::string> columns = { MediaColumn::MEDIA_FILE_PATH, PhotoColumn::PHOTO_DIRTY,
80         PhotoColumn::PHOTO_CLOUD_ID };
81     auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
82     if (resultSet == nullptr) {
83         MEDIA_ERR_LOG("resultSet is null");
84         return photoInfoList;
85     }
86     while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
87         PhotoInfo photoInfo;
88         photoInfo.data = DfxUtils::GetSafePath(GetStringVal(MediaColumn::MEDIA_FILE_PATH, resultSet));
89         photoInfo.dirty = GetInt32Val(PhotoColumn::PHOTO_DIRTY, resultSet);
90         photoInfo.cloudVersion = GetInt32Val(PhotoColumn::PHOTO_CLOUD_ID, resultSet);
91         photoInfoList.push_back(photoInfo);
92     }
93     return photoInfoList;
94 }
95 
ParseResultSet(const string & querySql,int32_t mediaTypePara,int32_t & photoInfoCount)96 static bool ParseResultSet(const string &querySql, int32_t mediaTypePara, int32_t &photoInfoCount)
97 {
98     auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
99     if (rdbStore == nullptr) {
100         MEDIA_ERR_LOG("rdbStore is nullptr!");
101         return false;
102     }
103     auto resultSet = rdbStore->QuerySql(querySql);
104     if (resultSet == nullptr) {
105         MEDIA_ERR_LOG("resultSet is null");
106         return false;
107     }
108     while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
109         if (mediaTypePara > 0) {
110             int32_t mediaType = GetInt32Val(MediaColumn::MEDIA_TYPE, resultSet);
111             if (mediaType == mediaTypePara) {
112                 photoInfoCount = GetInt32Val(RECORD_COUNT, resultSet);
113             }
114         } else {
115             photoInfoCount = GetInt32Val(RECORD_COUNT, resultSet);
116         }
117     }
118     return true;
119 }
120 
BuildDbInfo(PhotoRecordInfo & photoRecordInfo)121 static void BuildDbInfo(PhotoRecordInfo &photoRecordInfo)
122 {
123     string databaseDir = MEDIA_DB_DIR + "/rdb";
124     if (access(databaseDir.c_str(), E_OK) != 0) {
125         MEDIA_WARN_LOG("can not get rdb through sandbox");
126         return;
127     }
128     string dbPath = databaseDir.append("/").append(MEDIA_DATA_ABILITY_DB_NAME);
129 
130     struct stat statInfo {};
131     if (stat(dbPath.c_str(), &statInfo) != 0) {
132         MEDIA_ERR_LOG("stat syscall err");
133         return;
134     }
135     photoRecordInfo.dbFileSize = statInfo.st_size;
136 
137     struct stat slaveStatInfo {};
138     if (stat(MEDIA_DB_FILE_SLAVE.c_str(), &slaveStatInfo) == 0) {
139         photoRecordInfo.slaveDbFileSize = slaveStatInfo.st_size;
140     }
141 }
142 
GetDuplicateLpathCountQuerrySql()143 static string GetDuplicateLpathCountQuerrySql()
144 {
145     return "SELECT COUNT(*) AS " + RECORD_COUNT + " FROM " +
146         PhotoAlbumColumns::TABLE + " WHERE COALESCE(lpath, '') IN (SELECT lpath FROM " +
147         PhotoAlbumColumns::TABLE + " WHERE " + PhotoAlbumColumns::ALBUM_TYPE + " IN (0, 2048) AND " +
148         "COALESCE(lpath, '') <> '' AND " + PhotoAlbumColumns::ALBUM_DIRTY +
149         " <> 4 GROUP BY lpath HAVING COUNT(1) > 1) AND COALESCE(PhotoAlbum.dirty, 1) <> 4";
150 }
151 
GetAbnormalLpathCountQuerySql()152 static string GetAbnormalLpathCountQuerySql()
153 {
154     return "SELECT COUNT(*) AS " + RECORD_COUNT + " FROM " +
155         PhotoAlbumColumns::TABLE + " WHERE COALESCE(lpath, '') = '' AND " +
156         PhotoAlbumColumns::ALBUM_TYPE + " != " + std::to_string(PhotoAlbumType::SYSTEM) + " AND " +
157         PhotoAlbumColumns::ALBUM_DIRTY + " != 4";
158 }
159 
QueryPhotoRecordInfo(PhotoRecordInfo & photoRecordInfo)160 int32_t DfxDatabaseUtils::QueryPhotoRecordInfo(PhotoRecordInfo &photoRecordInfo)
161 {
162     const string filterCondition = MediaColumn::MEDIA_TIME_PENDING + " = 0 AND " +
163         PhotoColumn::PHOTO_SYNC_STATUS + " = " +
164         to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)) + " AND " +
165         PhotoColumn::PHOTO_CLEAN_FLAG + " = " +
166         to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN));
167 
168     const string imageAndVideoCountQuerySql = "SELECT " + MediaColumn::MEDIA_TYPE + ", COUNT(*) AS " + RECORD_COUNT +
169         " FROM " + PhotoColumn::PHOTOS_TABLE + " WHERE " + filterCondition + " GROUP BY " + MediaColumn::MEDIA_TYPE;
170 
171     const string abnormalSizeCountQuerySql = "SELECT COUNT(*) AS " + RECORD_COUNT + " FROM " +
172         PhotoColumn::PHOTOS_TABLE + " WHERE " + MediaColumn::MEDIA_SIZE + " = " + ABNORMAL_VALUE +
173         " AND " + filterCondition;
174 
175     const string abnormalWidthHeightQuerySql = "SELECT COUNT(*) AS " + RECORD_COUNT + " FROM " +
176         PhotoColumn::PHOTOS_TABLE + " WHERE (" + PhotoColumn::PHOTO_WIDTH + " = " + ABNORMAL_VALUE +
177         " OR " + PhotoColumn::PHOTO_HEIGHT + " = " + ABNORMAL_VALUE + ") AND " + filterCondition;
178 
179     const string abnormalVideoDurationQuerySql = "SELECT COUNT(*) AS " + RECORD_COUNT + " FROM " +
180         PhotoColumn::PHOTOS_TABLE + " WHERE " + MediaColumn::MEDIA_DURATION + " = " + ABNORMAL_VALUE +
181         " AND " + MediaColumn::MEDIA_TYPE + " = " + std::to_string(MEDIA_TYPE_VIDEO) + " AND " + filterCondition;
182 
183     const string totalAbnormalRecordSql = "SELECT COUNT(*) AS " + RECORD_COUNT + " FROM " +
184         PhotoColumn::PHOTOS_TABLE + " WHERE (" + MediaColumn::MEDIA_SIZE + " = 0 OR " +
185         MediaColumn::MEDIA_SIZE + " IS NULL OR " + MediaColumn::MEDIA_MIME_TYPE + " IS NULL OR " +
186         MediaColumn::MEDIA_MIME_TYPE + " = '' OR " + PhotoColumn::PHOTO_HEIGHT + " = 0 OR " +
187         PhotoColumn::PHOTO_HEIGHT + " IS NULL OR " + PhotoColumn::PHOTO_WIDTH + " = 0 OR " +
188         PhotoColumn::PHOTO_WIDTH + " IS NULL OR ((" + MediaColumn::MEDIA_DURATION + " IS NULL OR " +
189         MediaColumn::MEDIA_DURATION + " = 0 ) AND " + MediaColumn::MEDIA_TYPE + " = " +
190         std::to_string(MEDIA_TYPE_VIDEO) + " )) AND " + filterCondition;
191 
192     const string duplicateLpathCountQuerySql = GetDuplicateLpathCountQuerrySql();
193     const string abnormalLpathCountQuerySql = GetAbnormalLpathCountQuerySql();
194 
195     bool ret = ParseResultSet(imageAndVideoCountQuerySql, MEDIA_TYPE_VIDEO, photoRecordInfo.videoCount);
196     ret = ParseResultSet(imageAndVideoCountQuerySql, MEDIA_TYPE_IMAGE, photoRecordInfo.imageCount) && ret;
197     ret = ParseResultSet(abnormalSizeCountQuerySql, 0, photoRecordInfo.abnormalSizeCount) && ret;
198     ret = ParseResultSet(abnormalWidthHeightQuerySql, 0, photoRecordInfo.abnormalWidthOrHeightCount) && ret;
199     ret = ParseResultSet(abnormalVideoDurationQuerySql, 0, photoRecordInfo.abnormalVideoDurationCount) && ret;
200     ret = ParseResultSet(totalAbnormalRecordSql, 0, photoRecordInfo.toBeUpdatedRecordCount) && ret;
201     ret = ParseResultSet(duplicateLpathCountQuerySql, 0, photoRecordInfo.duplicateLpathCount) && ret;
202     ret = ParseResultSet(abnormalLpathCountQuerySql, 0, photoRecordInfo.abnormalLpathCount) && ret;
203 
204     BuildDbInfo(photoRecordInfo);
205     return ret ? E_OK : E_FAIL;
206 }
207 
QueryAnalysisVersion(const std::string & table,const std::string & column)208 int32_t DfxDatabaseUtils::QueryAnalysisVersion(const std::string &table, const std::string &column)
209 {
210     NativeRdb::RdbPredicates predicates(table);
211     string whereClause = "max(" + column + ") AS version";
212     std::vector<std::string> columns = { whereClause };
213     string version = "version";
214     double count;
215     int32_t errCode = QueryDouble(predicates, columns, version, count);
216     if (errCode != E_OK) {
217         MEDIA_ERR_LOG("query analysis version fail: %{public}d", errCode);
218     }
219     return static_cast<int32_t> (count);
220 }
221 
QueryDbVersion()222 int32_t DfxDatabaseUtils::QueryDbVersion()
223 {
224     int64_t dbVersion = 0;
225     MediaLibraryRdbStore::QueryPragma("user_version", dbVersion);
226     return static_cast<int32_t> (dbVersion);
227 }
228 
QueryInt(const NativeRdb::AbsRdbPredicates & predicates,const std::vector<std::string> & columns,const std::string & queryColumn,int32_t & value)229 int32_t DfxDatabaseUtils::QueryInt(const NativeRdb::AbsRdbPredicates &predicates,
230     const std::vector<std::string> &columns, const std::string &queryColumn, int32_t &value)
231 {
232     auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
233     if (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK) {
234         return E_DB_FAIL;
235     }
236     value = GetInt32Val(queryColumn, resultSet);
237     return E_OK;
238 }
239 
QueryDouble(const NativeRdb::AbsRdbPredicates & predicates,const std::vector<std::string> & columns,const std::string & queryColumn,double & value)240 int32_t DfxDatabaseUtils::QueryDouble(const NativeRdb::AbsRdbPredicates &predicates,
241     const std::vector<std::string> &columns, const std::string &queryColumn, double &value)
242 {
243     auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
244     if (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK) {
245         return E_DB_FAIL;
246     }
247     value = GetDoubleVal(queryColumn, resultSet);
248     return E_OK;
249 }
250 
QueryDownloadedAndGeneratedThumb(int32_t & downloadedThumb,int32_t & generatedThumb)251 int32_t DfxDatabaseUtils::QueryDownloadedAndGeneratedThumb(int32_t& downloadedThumb, int32_t& generatedThumb)
252 {
253     // cloud image that are all generated
254     NativeRdb::RdbPredicates generatePredicates(PhotoColumn::PHOTOS_TABLE);
255     std::vector<std::string> columns = { "count(1) AS count" };
256     std::string queryColumn = "count";
257     int32_t cloudImage = 2;
258     int32_t thumbGeneratedFinished = 2;
259     generatePredicates.GreaterThanOrEqualTo(PhotoColumn::PHOTO_POSITION, cloudImage)->And()
260         ->GreaterThanOrEqualTo(PhotoColumn::PHOTO_THUMBNAIL_READY, thumbGeneratedFinished);
261     int32_t errCode = QueryInt(generatePredicates, columns, queryColumn, generatedThumb);
262     if (errCode != E_OK) {
263         MEDIA_ERR_LOG("query generated image fail: %{public}d", errCode);
264         return errCode;
265     }
266 
267     // cloud image that are downloaded
268     NativeRdb::RdbPredicates downloadPredicates(PhotoColumn::PHOTOS_TABLE);
269     downloadPredicates.GreaterThanOrEqualTo(PhotoColumn::PHOTO_POSITION, cloudImage)->And()
270         ->EqualTo(PhotoColumn::PHOTO_THUMB_STATUS, 0);
271     errCode = QueryInt(downloadPredicates, columns, queryColumn, downloadedThumb);
272     if (errCode != E_OK) {
273         MEDIA_ERR_LOG("query downloaded image fail: %{public}d", errCode);
274         return errCode;
275     }
276     return E_OK;
277 }
278 
QueryTotalCloudThumb(int32_t & totalDownload)279 int32_t DfxDatabaseUtils::QueryTotalCloudThumb(int32_t& totalDownload)
280 {
281     int32_t cloudImage = 2;
282     NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
283     predicates.GreaterThanOrEqualTo(PhotoColumn::PHOTO_POSITION, cloudImage);
284     std::vector<std::string> columns = { "count(1) AS count" };
285     std::string queryColumn = "count";
286     int32_t errCode = QueryInt(predicates, columns, queryColumn, totalDownload);
287     if (errCode != E_OK) {
288         MEDIA_ERR_LOG("query total download image fail: %{public}d", errCode);
289         return errCode;
290     }
291     return E_OK;
292 }
293 
294 } // namespace Media
295 } // namespace OHOS