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 "relational_store_utils.h"
17 #include "native_log.h"
18 
19 namespace OHOS {
20 namespace Relational {
MallocCString(const std::string & origin)21     char* MallocCString(const std::string& origin)
22     {
23         if (origin.empty()) {
24             return nullptr;
25         }
26         auto len = origin.length() + 1;
27         char* res = static_cast<char*>(malloc(sizeof(char) * len));
28         if (res == nullptr) {
29             return nullptr;
30         }
31         return std::char_traits<char>::copy(res, origin.c_str(), len);
32     }
33 
ValueTypeToValueObjectBlob(const ValueType & value)34     NativeRdb::ValueObject ValueTypeToValueObjectBlob(const ValueType& value)
35     {
36         std::vector<uint8_t> blob = std::vector<uint8_t>();
37         for (int64_t j = 0; j < value.Uint8Array.size; j++) {
38             blob.push_back(value.Uint8Array.head[j]);
39         }
40         return NativeRdb::ValueObject(blob);
41     }
42 
ValueTypeToValueObjectAsset(const ValueType & value)43     NativeRdb::ValueObject ValueTypeToValueObjectAsset(const ValueType& value)
44     {
45         std::string modifyTime = value.asset.modifyTime;
46         std::string size = value.asset.size;
47         NativeRdb::ValueObject::Asset asset = {
48             .status = value.asset.status,
49             .name = value.asset.name,
50             .uri = value.asset.uri,
51             .createTime = value.asset.createTime,
52             .modifyTime = modifyTime,
53             .size = size,
54             .hash = modifyTime + "_" + size,
55             .path = value.asset.path
56         };
57         return NativeRdb::ValueObject(asset);
58     }
59 
ValueTypeToValueObjectAssets(const ValueType & value)60     NativeRdb::ValueObject ValueTypeToValueObjectAssets(const ValueType& value)
61     {
62         std::vector<NativeRdb::ValueObject::Asset> assets = std::vector<NativeRdb::ValueObject::Asset>();
63         for (int64_t j = 0; j < value.assets.size; j++) {
64             Asset asset = value.assets.head[j];
65             std::string modifyTime = asset.modifyTime;
66             std::string size = asset.size;
67             NativeRdb::ValueObject::Asset nativeAsset = {
68                 .status = asset.status,
69                 .name = asset.name,
70                 .uri = asset.uri,
71                 .createTime = asset.createTime,
72                 .modifyTime = modifyTime,
73                 .size = size,
74                 .hash = modifyTime + "_" + size,
75                 .path = asset.path
76             };
77             assets.push_back(nativeAsset);
78         }
79         return NativeRdb::ValueObject(assets);
80     }
81 
ValueTypeToValueObject(const ValueType & value)82     NativeRdb::ValueObject ValueTypeToValueObject(const ValueType& value)
83     {
84         NativeRdb::ValueObject valueObject;
85         switch (value.tag) {
86             case TYPE_NULL: {
87                 valueObject = NativeRdb::ValueObject();
88                 break;
89             }
90             case TYPE_INT: {
91                 valueObject = NativeRdb::ValueObject(value.integer);
92                 break;
93             }
94             case TYPE_DOU: {
95                 valueObject = NativeRdb::ValueObject(value.dou);
96                 break;
97             }
98             case TYPE_STR: {
99                 valueObject = NativeRdb::ValueObject(value.string);
100                 break;
101             }
102             case TYPE_BOOL: {
103                 valueObject = NativeRdb::ValueObject(value.boolean);
104                 break;
105             }
106             case TYPE_BLOB: {
107                 valueObject = ValueTypeToValueObjectBlob(value);
108                 break;
109             }
110             case TYPE_ASSET: {
111                 valueObject = ValueTypeToValueObjectAsset(value);
112                 break;
113             }
114             case TYPE_ASSETS: {
115                 valueObject = ValueTypeToValueObjectAssets(value);
116                 break;
117             }
118             default:
119                 valueObject = NativeRdb::ValueObject();
120                 break;
121         }
122         return valueObject;
123     }
124 
ValueObjectToValueTypeAsset(const NativeRdb::ValueObject & object)125     ValueType ValueObjectToValueTypeAsset(const NativeRdb::ValueObject& object)
126     {
127         NativeRdb::ValueObject::Asset val;
128         object.GetAsset(val);
129         Asset asset = Asset {
130             .name = MallocCString(val.name),
131             .uri = MallocCString(val.uri),
132             .path = MallocCString(val.path),
133             .createTime = MallocCString(val.createTime),
134             .modifyTime = MallocCString(val.modifyTime),
135             .size = MallocCString(val.size),
136             .status = val.status
137         };
138         return ValueType {.asset = asset, .tag = TYPE_ASSET};
139     }
140 
ValueObjectToValueTypeAssets(const NativeRdb::ValueObject & object)141     ValueType ValueObjectToValueTypeAssets(const NativeRdb::ValueObject& object)
142     {
143         NativeRdb::ValueObject::Assets val;
144         object.GetAssets(val);
145         Assets assets = Assets {.head = static_cast<Asset*>(malloc(val.size() * sizeof(Asset))), .size = val.size()};
146         if (assets.head == nullptr) {
147             return ValueType {.assets = Assets{nullptr, -1}, .tag = TYPE_ASSETS};
148         }
149         for (std::size_t i = 0; i < val.size(); i++) {
150             assets.head[i] = Asset {
151                 .name = MallocCString(val[i].name),
152                 .uri = MallocCString(val[i].uri),
153                 .path = MallocCString(val[i].path),
154                 .createTime = MallocCString(val[i].createTime),
155                 .modifyTime = MallocCString(val[i].modifyTime),
156                 .size = MallocCString(val[i].size),
157                 .status = static_cast<int32_t>(val[i].status)
158             };
159         }
160         return ValueType {.assets = assets, .tag = TYPE_ASSETS};
161     }
162 
ValueObjectToValueType(const NativeRdb::ValueObject & object)163     ValueType ValueObjectToValueType(const NativeRdb::ValueObject& object)
164     {
165         switch (object.GetType()) {
166             case NativeRdb::ValueObject::TYPE_NULL:
167                 return ValueType {.tag = TYPE_NULL};
168             case NativeRdb::ValueObject::TYPE_INT: {
169                 int64_t val;
170                 object.GetLong(val);
171                 return ValueType {.integer = val, .tag = TYPE_INT};
172             }
173             case NativeRdb::ValueObject::TYPE_DOUBLE: {
174                 double val;
175                 object.GetDouble(val);
176                 return ValueType {.dou = val, .tag = TYPE_DOU};
177             }
178             case NativeRdb::ValueObject::TYPE_STRING: {
179                 std::string val;
180                 object.GetString(val);
181                 return ValueType {.string = MallocCString(val), .tag = TYPE_STR};
182             }
183             case NativeRdb::ValueObject::TYPE_BOOL: {
184                 bool val;
185                 object.GetBool(val);
186                 return ValueType {.boolean = val, .tag = TYPE_BOOL};
187             }
188             case NativeRdb::ValueObject::TYPE_BLOB: {
189                 std::vector<uint8_t> val;
190                 object.GetBlob(val);
191                 CArrUI8 arr = CArrUI8 {.head = static_cast<uint8_t*>(malloc(val.size() * sizeof(uint8_t))),
192                     .size = val.size()};
193                 if (arr.head == nullptr) {
194                     return ValueType {.Uint8Array = CArrUI8 {nullptr, -1}, .tag = TYPE_BLOB};
195                 }
196                 return ValueType {.Uint8Array = arr, .tag = TYPE_BLOB};
197             }
198             case NativeRdb::ValueObject::TYPE_ASSET: {
199                 return ValueObjectToValueTypeAsset(object);
200             }
201             case NativeRdb::ValueObject::TYPE_ASSETS: {
202                 return ValueObjectToValueTypeAssets(object);
203             }
204             case NativeRdb::ValueObject::TYPE_BUTT:
205                 return ValueType {.tag = 128};
206             default:
207                 return ValueType {.tag = TYPE_NULL};
208         }
209     }
210 }
211 }