1 | /** |
2 | * Copyright 2021 Alibaba, Inc. and its affiliates. All Rights Reserved. |
3 | * |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
5 | * you may not use this file except in compliance with the License. |
6 | * You may obtain a copy of the License at |
7 | * |
8 | * http://www.apache.org/licenses/LICENSE-2.0 |
9 | * |
10 | * Unless required by applicable law or agreed to in writing, software |
11 | * distributed under the License is distributed on an "AS IS" BASIS, |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
13 | * See the License for the specific language governing permissions and |
14 | * limitations under the License. |
15 | * |
16 | * \author guonix |
17 | * \date Dec 2020 |
18 | * \brief |
19 | */ |
20 | |
21 | #pragma once |
22 | |
23 | #include "proto/common.pb.h" |
24 | #include "error_code.h" |
25 | #include "logger.h" |
26 | #include "types.h" |
27 | |
28 | namespace proxima { |
29 | namespace be { |
30 | |
31 | struct DataTypeCodeBook { |
32 | static DataTypes Get(proto::DataType type) { |
33 | DataTypes data_types = DataTypes::UNDEFINED; |
34 | switch (type) { |
35 | case proto::DataType::DT_BINARY: |
36 | data_types = DataTypes::BINARY; |
37 | break; |
38 | case proto::DataType::DT_STRING: |
39 | data_types = DataTypes::STRING; |
40 | break; |
41 | case proto::DataType::DT_BOOL: |
42 | data_types = DataTypes::BOOL; |
43 | break; |
44 | case proto::DataType::DT_INT32: |
45 | data_types = DataTypes::INT32; |
46 | break; |
47 | case proto::DataType::DT_INT64: |
48 | data_types = DataTypes::INT64; |
49 | break; |
50 | case proto::DataType::DT_UINT32: |
51 | data_types = DataTypes::UINT32; |
52 | break; |
53 | case proto::DataType::DT_UINT64: |
54 | data_types = DataTypes::UINT64; |
55 | break; |
56 | case proto::DataType::DT_FLOAT: |
57 | data_types = DataTypes::FLOAT; |
58 | break; |
59 | case proto::DataType::DT_DOUBLE: |
60 | data_types = DataTypes::DOUBLE; |
61 | break; |
62 | case proto::DataType::DT_VECTOR_BINARY32: |
63 | data_types = DataTypes::VECTOR_BINARY32; |
64 | break; |
65 | case proto::DataType::DT_VECTOR_BINARY64: |
66 | data_types = DataTypes::VECTOR_BINARY64; |
67 | break; |
68 | case proto::DataType::DT_VECTOR_FP16: |
69 | data_types = DataTypes::VECTOR_FP16; |
70 | break; |
71 | case proto::DataType::DT_VECTOR_FP32: |
72 | data_types = DataTypes::VECTOR_FP32; |
73 | break; |
74 | case proto::DataType::DT_VECTOR_FP64: |
75 | data_types = DataTypes::VECTOR_FP64; |
76 | break; |
77 | case proto::DataType::DT_VECTOR_INT4: |
78 | data_types = DataTypes::VECTOR_INT4; |
79 | break; |
80 | case proto::DataType::DT_VECTOR_INT8: |
81 | data_types = DataTypes::VECTOR_INT8; |
82 | break; |
83 | case proto::DataType::DT_VECTOR_INT16: |
84 | data_types = DataTypes::VECTOR_INT16; |
85 | default: |
86 | break; |
87 | } |
88 | return data_types; |
89 | } |
90 | |
91 | static proto::DataType Get(DataTypes type) { |
92 | proto::DataType data_type = proto::DataType::DT_UNDEFINED; |
93 | switch (type) { |
94 | case DataTypes::BINARY: |
95 | data_type = proto::DataType::DT_BINARY; |
96 | break; |
97 | case DataTypes::STRING: |
98 | data_type = proto::DataType::DT_STRING; |
99 | break; |
100 | case DataTypes::BOOL: |
101 | data_type = proto::DataType::DT_BOOL; |
102 | break; |
103 | case DataTypes::INT32: |
104 | data_type = proto::DataType::DT_INT32; |
105 | break; |
106 | case DataTypes::INT64: |
107 | data_type = proto::DataType::DT_INT64; |
108 | break; |
109 | case DataTypes::UINT32: |
110 | data_type = proto::DataType::DT_UINT32; |
111 | break; |
112 | case DataTypes::UINT64: |
113 | data_type = proto::DataType::DT_UINT64; |
114 | break; |
115 | case DataTypes::FLOAT: |
116 | data_type = proto::DataType::DT_FLOAT; |
117 | break; |
118 | case DataTypes::DOUBLE: |
119 | data_type = proto::DataType::DT_DOUBLE; |
120 | break; |
121 | case DataTypes::VECTOR_BINARY32: |
122 | data_type = proto::DataType::DT_VECTOR_BINARY32; |
123 | break; |
124 | case DataTypes::VECTOR_BINARY64: |
125 | data_type = proto::DataType::DT_VECTOR_BINARY64; |
126 | break; |
127 | case DataTypes::VECTOR_FP16: |
128 | data_type = proto::DataType::DT_VECTOR_FP16; |
129 | break; |
130 | case DataTypes::VECTOR_FP32: |
131 | data_type = proto::DataType::DT_VECTOR_FP32; |
132 | break; |
133 | case DataTypes::VECTOR_FP64: |
134 | data_type = proto::DataType::DT_VECTOR_FP64; |
135 | break; |
136 | case DataTypes::VECTOR_INT4: |
137 | data_type = proto::DataType::DT_VECTOR_INT4; |
138 | break; |
139 | case DataTypes::VECTOR_INT8: |
140 | data_type = proto::DataType::DT_VECTOR_INT8; |
141 | break; |
142 | case DataTypes::VECTOR_INT16: |
143 | data_type = proto::DataType::DT_VECTOR_INT16; |
144 | default: |
145 | break; |
146 | } |
147 | |
148 | return data_type; |
149 | } |
150 | }; |
151 | |
152 | struct IndexParamsHelper { |
153 | static int Append(const proto::GenericKeyValue &kv, |
154 | aitheta2::IndexParams *params) { |
155 | if (!kv.IsInitialized()) { |
156 | return PROXIMA_BE_ERROR_CODE(InvalidArgument); |
157 | } |
158 | switch (kv.value().value_oneof_case()) { |
159 | case proto::GenericValue::ValueOneofCase::kStringValue: |
160 | params->insert<char *>( |
161 | kv.key(), const_cast<char *>(kv.value().string_value().c_str())); |
162 | break; |
163 | case proto::GenericValue::ValueOneofCase::kBoolValue: |
164 | params->insert<bool>(kv.key(), kv.value().bool_value()); |
165 | break; |
166 | case proto::GenericValue::ValueOneofCase::kInt32Value: |
167 | params->insert<int32_t>(kv.key(), kv.value().int32_value()); |
168 | break; |
169 | case proto::GenericValue::ValueOneofCase::kInt64Value: |
170 | params->insert<int64_t>(kv.key(), kv.value().int64_value()); |
171 | break; |
172 | case proto::GenericValue::ValueOneofCase::kUint32Value: |
173 | params->insert<uint32_t>(kv.key(), kv.value().uint32_value()); |
174 | break; |
175 | case proto::GenericValue::ValueOneofCase::kUint64Value: |
176 | params->insert<uint64_t>(kv.key(), kv.value().uint64_value()); |
177 | break; |
178 | case proto::GenericValue::ValueOneofCase::kFloatValue: |
179 | params->insert<float>(kv.key(), kv.value().float_value()); |
180 | break; |
181 | case proto::GenericValue::ValueOneofCase::kDoubleValue: |
182 | params->insert<double>(kv.key(), kv.value().double_value()); |
183 | break; |
184 | default: |
185 | LOG_DEBUG("None value or kBytes has been set, skip this" ); |
186 | break; |
187 | } |
188 | return 0; |
189 | } |
190 | |
191 | static int Append(const proto::KeyValuePair &kv, |
192 | aitheta2::IndexParams *params) { |
193 | if (!kv.IsInitialized()) { |
194 | return PROXIMA_BE_ERROR_CODE(InvalidArgument); |
195 | } |
196 | params->set(kv.key(), kv.value()); |
197 | return 0; |
198 | } |
199 | |
200 | static int SerializeToParams( |
201 | const google::protobuf::RepeatedPtrField<be::proto::KeyValuePair> &maps, |
202 | aitheta2::IndexParams *params) { |
203 | int count = maps.size(); |
204 | while (count--) { |
205 | Append(maps.at(count), params); |
206 | } |
207 | return 0; |
208 | } |
209 | |
210 | static int SerializeToPB( |
211 | const aitheta2::IndexParams ¶ms, |
212 | google::protobuf::RepeatedPtrField<be::proto::KeyValuePair> *maps) { |
213 | for (const auto &it : params.hypercube().cubes()) { |
214 | auto *kv = maps->Add(); |
215 | kv->set_key(it.first); |
216 | kv->set_value(it.second.cast<std::string>()); |
217 | } |
218 | return 0; |
219 | } |
220 | }; |
221 | |
222 | //! Code book for OperationTypes |
223 | struct OperationTypesCodeBook { |
224 | static OperationTypes Get(proto::OperationType type) { |
225 | if (type == proto::OP_INSERT) { |
226 | return OperationTypes::INSERT; |
227 | } else if (type == proto::OP_UPDATE) { |
228 | return OperationTypes::UPDATE; |
229 | } else { |
230 | return OperationTypes::DELETE; |
231 | } |
232 | } |
233 | }; |
234 | |
235 | } // namespace be |
236 | } // namespace proxima |
237 | |