/Users/deen/code/yugabyte-db/src/yb/common/ql_type.cc
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright (c) YugaByte, Inc. |
2 | | // |
3 | | // Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except |
4 | | // in compliance with the License. You may obtain a copy of the License at |
5 | | // |
6 | | // http://www.apache.org/licenses/LICENSE-2.0 |
7 | | // |
8 | | // Unless required by applicable law or agreed to in writing, software distributed under the License |
9 | | // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
10 | | // or implied. See the License for the specific language governing permissions and limitations |
11 | | // under the License. |
12 | | // |
13 | | |
14 | | #include "yb/common/ql_type.h" |
15 | | |
16 | | #include "yb/common/common.pb.h" |
17 | | #include "yb/common/types.h" |
18 | | |
19 | | #include "yb/gutil/macros.h" |
20 | | |
21 | | #include "yb/util/result.h" |
22 | | |
23 | | namespace yb { |
24 | | |
25 | | using std::shared_ptr; |
26 | | |
27 | | //-------------------------------------------------------------------------------------------------- |
28 | | // The following functions are to construct QLType objects. |
29 | | |
30 | | shared_ptr<QLType> QLType::Create( |
31 | 1.63M | DataType data_type, const std::vector<shared_ptr<QLType>>& params) { |
32 | 1.63M | switch (data_type) { |
33 | 381k | case DataType::LIST: |
34 | 381k | DCHECK_EQ(params.size(), 1); |
35 | 381k | return CreateCollectionType<DataType::LIST>(params); |
36 | 972k | case DataType::MAP: |
37 | 972k | DCHECK_EQ(params.size(), 2); |
38 | 972k | return CreateCollectionType<DataType::MAP>(params); |
39 | 252k | case DataType::SET: |
40 | 252k | DCHECK_EQ(params.size(), 1); |
41 | 252k | return CreateCollectionType<DataType::SET>(params); |
42 | 23.3k | case DataType::FROZEN: |
43 | 23.3k | DCHECK_EQ(params.size(), 1); |
44 | 23.3k | return CreateCollectionType<DataType::FROZEN>(params); |
45 | 0 | case DataType::TUPLE: |
46 | 0 | return CreateCollectionType<DataType::TUPLE>(params); |
47 | | // User-defined types cannot be created like this |
48 | 0 | case DataType::USER_DEFINED_TYPE: |
49 | 0 | LOG(FATAL) << "Unsupported constructor for user-defined type"; |
50 | 0 | return nullptr; |
51 | 0 | default: |
52 | 0 | DCHECK_EQ(params.size(), 0); |
53 | 0 | return Create(data_type); |
54 | 1.63M | } |
55 | 1.63M | } |
56 | | |
57 | 148M | shared_ptr<QLType> QLType::Create(DataType data_type) { |
58 | 148M | switch (data_type) { |
59 | 697k | case DataType::UNKNOWN_DATA: |
60 | 697k | return CreatePrimitiveType<DataType::UNKNOWN_DATA>(); |
61 | 160k | case DataType::NULL_VALUE_TYPE: |
62 | 160k | return CreatePrimitiveType<DataType::NULL_VALUE_TYPE>(); |
63 | 1.35M | case DataType::INT8: |
64 | 1.35M | return CreatePrimitiveType<DataType::INT8>(); |
65 | 847k | case DataType::INT16: |
66 | 847k | return CreatePrimitiveType<DataType::INT16>(); |
67 | 38.8M | case DataType::INT32: |
68 | 38.8M | return CreatePrimitiveType<DataType::INT32>(); |
69 | 1.30M | case DataType::INT64: |
70 | 1.30M | return CreatePrimitiveType<DataType::INT64>(); |
71 | 52.6M | case DataType::STRING: |
72 | 52.6M | return CreatePrimitiveType<DataType::STRING>(); |
73 | 3.20M | case DataType::BOOL: |
74 | 3.20M | return CreatePrimitiveType<DataType::BOOL>(); |
75 | 179k | case DataType::FLOAT: |
76 | 179k | return CreatePrimitiveType<DataType::FLOAT>(); |
77 | 1.26M | case DataType::DOUBLE: |
78 | 1.26M | return CreatePrimitiveType<DataType::DOUBLE>(); |
79 | 21.2M | case DataType::BINARY: |
80 | 21.2M | return CreatePrimitiveType<DataType::BINARY>(); |
81 | 14.5M | case DataType::TIMESTAMP: |
82 | 14.5M | return CreatePrimitiveType<DataType::TIMESTAMP>(); |
83 | 54.9k | case DataType::DECIMAL: |
84 | 54.9k | return CreatePrimitiveType<DataType::DECIMAL>(); |
85 | 162k | case DataType::VARINT: |
86 | 162k | return CreatePrimitiveType<DataType::VARINT>(); |
87 | 644k | case DataType::INET: |
88 | 644k | return CreatePrimitiveType<DataType::INET>(); |
89 | 19.4k | case DataType::JSONB: |
90 | 19.4k | return CreatePrimitiveType<DataType::JSONB>(); |
91 | 854k | case DataType::UUID: |
92 | 854k | return CreatePrimitiveType<DataType::UUID>(); |
93 | 2.41k | case DataType::TIMEUUID: |
94 | 2.41k | return CreatePrimitiveType<DataType::TIMEUUID>(); |
95 | 3.87k | case DataType::DATE: |
96 | 3.87k | return CreatePrimitiveType<DataType::DATE>(); |
97 | 3.05k | case DataType::TIME: |
98 | 3.05k | return CreatePrimitiveType<DataType::TIME>(); |
99 | | |
100 | | // Create empty parametric types and raise error during semantic check. |
101 | 281 | case DataType::LIST: |
102 | 281 | return CreateTypeList(); |
103 | 479 | case DataType::MAP: |
104 | 479 | return CreateTypeMap(); |
105 | 293 | case DataType::SET: |
106 | 293 | return CreateTypeSet(); |
107 | 390 | case DataType::TUPLE: |
108 | 390 | return CreateCollectionType<DataType::TUPLE>({}); |
109 | 0 | case DataType::FROZEN: |
110 | 0 | return CreateTypeFrozen(); |
111 | | |
112 | | // Kudu datatypes. |
113 | 0 | case UINT8: |
114 | 0 | return CreatePrimitiveType<DataType::UINT8>(); |
115 | 0 | case UINT16: |
116 | 0 | return CreatePrimitiveType<DataType::UINT16>(); |
117 | 10.1M | case UINT32: |
118 | 10.1M | return CreatePrimitiveType<DataType::UINT32>(); |
119 | 14.9k | case UINT64: |
120 | 14.9k | return CreatePrimitiveType<DataType::UINT64>(); |
121 | | |
122 | | // Datatype for variadic builtin function. |
123 | 0 | case TYPEARGS: |
124 | 0 | return CreatePrimitiveType<DataType::TYPEARGS>(); |
125 | | |
126 | | // User-defined types cannot be created like this |
127 | 0 | case DataType::USER_DEFINED_TYPE: |
128 | 0 | LOG(FATAL) << "Unsupported constructor for user-defined type"; |
129 | 0 | return nullptr; |
130 | | |
131 | 1.38k | case DataType::GIN_NULL: |
132 | 1.38k | return CreatePrimitiveType<DataType::GIN_NULL>(); |
133 | 148M | } |
134 | 0 | LOG(FATAL) << "Not supported datatype " << ToCQLString(data_type); |
135 | 0 | return nullptr; |
136 | 148M | } |
137 | | |
138 | 5.48k | bool QLType::IsValidPrimaryType(DataType type) { |
139 | 5.48k | switch (type) { |
140 | 2 | case DataType::MAP: FALLTHROUGH_INTENDED; |
141 | 4 | case DataType::SET: FALLTHROUGH_INTENDED; |
142 | 6 | case DataType::LIST: FALLTHROUGH_INTENDED; |
143 | 6 | case DataType::TUPLE: FALLTHROUGH_INTENDED; |
144 | 6 | case DataType::JSONB: FALLTHROUGH_INTENDED; |
145 | 6 | case DataType::USER_DEFINED_TYPE: |
146 | 6 | return false; |
147 | | |
148 | 5.48k | default: |
149 | | // Let all other types go. Because we already process column datatype before getting here, |
150 | | // just assume that they are all valid types. |
151 | 5.48k | return true; |
152 | 5.48k | } |
153 | 5.48k | } |
154 | | |
155 | | shared_ptr<QLType> QLType::CreateTypeMap(std::shared_ptr<QLType> key_type, |
156 | 45.4k | std::shared_ptr<QLType> value_type) { |
157 | 45.4k | std::vector<shared_ptr<QLType>> params = {key_type, value_type}; |
158 | 45.4k | return CreateCollectionType<DataType::MAP>(params); |
159 | 45.4k | } |
160 | | |
161 | 45.2k | std::shared_ptr<QLType> QLType::CreateTypeMap(DataType key_type, DataType value_type) { |
162 | 45.2k | return CreateTypeMap(QLType::Create(key_type), QLType::Create(value_type)); |
163 | 45.2k | } |
164 | | |
165 | 22.1k | shared_ptr<QLType> QLType::CreateTypeList(std::shared_ptr<QLType> value_type) { |
166 | 22.1k | std::vector<shared_ptr<QLType>> params(1, value_type); |
167 | 22.1k | return CreateCollectionType<DataType::LIST>(params); |
168 | 22.1k | } |
169 | | |
170 | 21.1k | std::shared_ptr<QLType> QLType::CreateTypeList(DataType value_type) { |
171 | 21.1k | return CreateTypeList(QLType::Create(value_type)); |
172 | 21.1k | } |
173 | | |
174 | 9.24k | shared_ptr<QLType> QLType::CreateTypeSet(std::shared_ptr<QLType> value_type) { |
175 | 9.24k | std::vector<shared_ptr<QLType>> params(1, value_type); |
176 | 9.24k | return CreateCollectionType<DataType::SET>(params); |
177 | 9.24k | } |
178 | | |
179 | 9.08k | std::shared_ptr<QLType> QLType::CreateTypeSet(DataType value_type) { |
180 | 9.08k | return CreateTypeSet(QLType::Create(value_type)); |
181 | 9.08k | } |
182 | | |
183 | 189 | shared_ptr<QLType> QLType::CreateTypeFrozen(shared_ptr<QLType> value_type) { |
184 | 189 | std::vector<shared_ptr<QLType>> params(1, value_type); |
185 | 189 | return CreateCollectionType<DataType::FROZEN>(params); |
186 | 189 | } |
187 | | |
188 | | //-------------------------------------------------------------------------------------------------- |
189 | | // ToPB and FromPB. |
190 | | |
191 | 2.08G | void QLType::ToQLTypePB(QLTypePB *pb_type) const { |
192 | 2.08G | pb_type->set_main(id_); |
193 | 2.08G | for (auto ¶m : params_) { |
194 | 732k | param->ToQLTypePB(pb_type->add_params()); |
195 | 732k | } |
196 | | |
197 | 2.08G | if (IsUserDefined()) { |
198 | 10.8k | auto udtype_info = pb_type->mutable_udtype_info(); |
199 | 10.8k | udtype_info->set_keyspace_name(udtype_keyspace_name()); |
200 | 10.8k | udtype_info->set_name(udtype_name()); |
201 | 10.8k | udtype_info->set_id(udtype_id()); |
202 | | |
203 | 21.0k | for (const auto &field_name : udtype_field_names()) { |
204 | 21.0k | udtype_info->add_field_names(field_name); |
205 | 21.0k | } |
206 | 10.8k | } |
207 | 2.08G | } |
208 | | |
209 | 76.0M | shared_ptr<QLType> QLType::FromQLTypePB(const QLTypePB& pb_type) { |
210 | 76.0M | if (pb_type.main() == USER_DEFINED_TYPE) { |
211 | 16.2k | auto ql_type = std::make_shared<QLType>(pb_type.udtype_info().keyspace_name(), |
212 | 16.2k | pb_type.udtype_info().name()); |
213 | 16.2k | std::vector<std::string> field_names; |
214 | 32.2k | for (const auto& field_name : pb_type.udtype_info().field_names()) { |
215 | 32.2k | field_names.push_back(field_name); |
216 | 32.2k | } |
217 | | |
218 | 16.2k | std::vector<shared_ptr<QLType>> field_types; |
219 | 32.2k | for (const auto& field_type : pb_type.params()) { |
220 | 32.2k | field_types.push_back(QLType::FromQLTypePB(field_type)); |
221 | 32.2k | } |
222 | | |
223 | 16.2k | ql_type->SetUDTypeFields(pb_type.udtype_info().id(), field_names, field_types); |
224 | 16.2k | return ql_type; |
225 | 16.2k | } |
226 | | |
227 | 76.0M | if (pb_type.params().empty()) { |
228 | 74.3M | return Create(pb_type.main()); |
229 | 74.3M | } |
230 | | |
231 | 1.71M | std::vector<shared_ptr<QLType>> params; |
232 | 2.60M | for (auto ¶m : pb_type.params()) { |
233 | 2.60M | params.push_back(FromQLTypePB(param)); |
234 | 2.60M | } |
235 | 1.71M | return Create(pb_type.main(), params); |
236 | 76.0M | } |
237 | | |
238 | 1.32k | std::shared_ptr<QLType> QLType::keys_type() const { |
239 | 1.32k | switch (id_) { |
240 | 905 | case MAP: |
241 | 905 | return params_[0]; |
242 | 402 | case LIST: |
243 | 402 | return QLType::Create(INT32); |
244 | 16 | case SET: |
245 | | // set has no keys, only values |
246 | 16 | return nullptr; |
247 | 0 | case TUPLE: |
248 | | // https://github.com/YugaByte/yugabyte-db/issues/936 |
249 | 0 | LOG(FATAL) << "Tuple type not implemented yet"; |
250 | |
|
251 | 6 | default: |
252 | | // elementary types have no keys or values |
253 | 6 | return nullptr; |
254 | 1.32k | } |
255 | 1.32k | } |
256 | | |
257 | 1.39k | std::shared_ptr<QLType> QLType::values_type() const { |
258 | 1.39k | switch (id_) { |
259 | 329 | case MAP: |
260 | 329 | return params_[1]; |
261 | 1.03k | case LIST: |
262 | 1.03k | return params_[0]; |
263 | 28 | case SET: |
264 | 28 | return params_[0]; |
265 | 0 | case TUPLE: |
266 | 0 | LOG(FATAL) << "Tuple type not implemented yet"; |
267 | |
|
268 | 0 | default: |
269 | | // other types have no keys or values |
270 | 0 | return nullptr; |
271 | 1.39k | } |
272 | 1.39k | } |
273 | | |
274 | 1.49M | const QLType::SharedPtr& QLType::param_type(size_t member_index) const { |
275 | 1.49M | DCHECK_LT(member_index, params_.size()); |
276 | 1.49M | return params_[member_index]; |
277 | 1.49M | } |
278 | | |
279 | | //-------------------------------------------------------------------------------------------------- |
280 | | // Logging routines. |
281 | 2.58M | const std::string QLType::ToCQLString(const DataType& datatype) { |
282 | 2.58M | switch (datatype) { |
283 | 58 | case DataType::UNKNOWN_DATA: return "unknown"; |
284 | 0 | case DataType::NULL_VALUE_TYPE: return "anytype"; |
285 | 124 | case DataType::INT8: return "tinyint"; |
286 | 143 | case DataType::INT16: return "smallint"; |
287 | 239k | case DataType::INT32: return "int"; |
288 | 28.8k | case DataType::INT64: return "bigint"; |
289 | 1.38M | case DataType::STRING: return "text"; |
290 | 114k | case DataType::BOOL: return "boolean"; |
291 | 192 | case DataType::FLOAT: return "float"; |
292 | 114k | case DataType::DOUBLE: return "double"; |
293 | 85.8k | case DataType::BINARY: return "blob"; |
294 | 553 | case DataType::TIMESTAMP: return "timestamp"; |
295 | 220 | case DataType::DECIMAL: return "decimal"; |
296 | 117 | case DataType::VARINT: return "varint"; |
297 | 100k | case DataType::INET: return "inet"; |
298 | 434 | case DataType::JSONB: return "jsonb"; |
299 | 100k | case DataType::LIST: return "list"; |
300 | 214k | case DataType::MAP: return "map"; |
301 | 43.3k | case DataType::SET: return "set"; |
302 | 157k | case DataType::UUID: return "uuid"; |
303 | 83 | case DataType::TIMEUUID: return "timeuuid"; |
304 | 0 | case DataType::TUPLE: return "tuple"; |
305 | 0 | case DataType::TYPEARGS: return "typeargs"; |
306 | 742 | case DataType::FROZEN: return "frozen"; |
307 | 0 | case DataType::USER_DEFINED_TYPE: return "user_defined_type"; |
308 | 125 | case DataType::DATE: return "date"; |
309 | 108 | case DataType::TIME: return "time"; |
310 | 0 | case DataType::UINT8: return "uint8"; |
311 | 0 | case DataType::UINT16: return "uint16"; |
312 | 0 | case DataType::UINT32: return "uint32"; |
313 | 0 | case DataType::UINT64: return "uint64"; |
314 | 0 | case DataType::GIN_NULL: return "gin_null"; |
315 | 2.58M | } |
316 | 0 | LOG(FATAL) << "Invalid datatype: " << datatype; |
317 | 0 | return "Undefined Type"; |
318 | 2.58M | } |
319 | | |
320 | 2.01M | std::string QLType::ToString() const { |
321 | 2.01M | std::stringstream ss; |
322 | 2.01M | ToString(ss); |
323 | 2.01M | return ss.str(); |
324 | 2.01M | } |
325 | | |
326 | 2.58M | void QLType::ToString(std::stringstream& os) const { |
327 | 2.58M | if (IsUserDefined()) { |
328 | | // UDTs can only be used in the keyspace they are defined in, so keyspace name is implied. |
329 | 507 | os << udtype_name(); |
330 | 2.58M | } else { |
331 | 2.58M | os << ToCQLString(id_); |
332 | 2.58M | if (!params_.empty()) { |
333 | 358k | os << "<"; |
334 | 932k | for (size_t i = 0; i < params_.size(); i++573k ) { |
335 | 573k | if (i > 0) { |
336 | 214k | os << ", "; |
337 | 214k | } |
338 | 573k | params_[i]->ToString(os); |
339 | 573k | } |
340 | 358k | os << ">"; |
341 | 358k | } |
342 | 2.58M | } |
343 | 2.58M | } |
344 | | |
345 | | bool QLType::DoesUserDefinedTypeIdExist(const QLTypePB& type_pb, |
346 | | const bool transitive, |
347 | 182 | const std::string& udt_id) { |
348 | 182 | if (type_pb.main() == USER_DEFINED_TYPE) { |
349 | 23 | if (type_pb.udtype_info().id() == udt_id) { |
350 | 4 | return true; |
351 | 4 | } |
352 | 19 | if (!transitive) { |
353 | 19 | return false; // Do not check params of the UDT if only looking for direct dependencies. |
354 | 19 | } |
355 | 19 | } |
356 | | |
357 | 159 | for (const auto& param : type_pb.params()) { |
358 | 48 | if (DoesUserDefinedTypeIdExist(param, transitive, udt_id)) { |
359 | 8 | return true; |
360 | 8 | } |
361 | 48 | } |
362 | 151 | return false; |
363 | 159 | } |
364 | | |
365 | | // Get the type ids of all UDTs referenced by this UDT. |
366 | | void QLType::GetUserDefinedTypeIds(const QLTypePB& type_pb, |
367 | | const bool transitive, |
368 | 134 | std::vector<std::string>* udt_ids) { |
369 | 134 | if (type_pb.main() == USER_DEFINED_TYPE) { |
370 | 11 | udt_ids->push_back(type_pb.udtype_info().id()); |
371 | 11 | if (!transitive) { |
372 | 0 | return; // Do not check params of the UDT if only looking for direct dependencies. |
373 | 0 | } |
374 | 11 | } |
375 | | |
376 | 134 | for (const auto& param : type_pb.params()) { |
377 | 45 | GetUserDefinedTypeIds(param, transitive, udt_ids); |
378 | 45 | } |
379 | 134 | } |
380 | | |
381 | 14 | Result<QLType::SharedPtr> QLType::GetUDTFieldTypeByName(const std::string& field_name) const { |
382 | 14 | SCHECK(IsUserDefined(), InternalError, "Can only be called on UDT"); |
383 | 14 | const auto idx = GetUDTypeFieldIdxByName(field_name); |
384 | 14 | if (!idx) { |
385 | 0 | return nullptr; |
386 | 0 | } |
387 | 14 | return param_type(*idx); |
388 | 14 | } |
389 | | |
390 | 108M | const TypeInfo* QLType::type_info() const { |
391 | 108M | return GetTypeInfo(id_); |
392 | 108M | } |
393 | | |
394 | | bool QLType::IsImplicitlyConvertible(const std::shared_ptr<QLType>& lhs_type, |
395 | 730k | const std::shared_ptr<QLType>& rhs_type) { |
396 | 730k | switch (QLType::GetConversionMode(lhs_type->main(), rhs_type->main())) { |
397 | 550k | case QLType::ConversionMode::kIdentical: FALLTHROUGH_INTENDED; |
398 | 713k | case QLType::ConversionMode::kSimilar: FALLTHROUGH_INTENDED; |
399 | 729k | case QLType::ConversionMode::kImplicit: |
400 | 729k | return true; |
401 | | |
402 | 152 | case QLType::ConversionMode::kFurtherCheck: |
403 | | // checking params convertibility |
404 | 152 | if (lhs_type->params().size() != rhs_type->params().size()) { |
405 | 0 | return false; |
406 | 0 | } |
407 | 357 | for (size_t i = 0; 152 i < lhs_type->params().size(); i++205 ) { |
408 | 205 | if (!IsImplicitlyConvertible(lhs_type->params().at(i), rhs_type->params().at(i))) { |
409 | 0 | return false; |
410 | 0 | } |
411 | 205 | } |
412 | 152 | return true; |
413 | | |
414 | 33 | case QLType::ConversionMode::kExplicit: FALLTHROUGH_INTENDED; |
415 | 142 | case QLType::ConversionMode::kNotAllowed: |
416 | 142 | return false; |
417 | 730k | } |
418 | | |
419 | 0 | LOG(FATAL) << "Unsupported conversion mode in switch statement"; |
420 | 0 | return false; |
421 | 730k | } |
422 | | |
423 | 733k | QLType::ConversionMode QLType::GetConversionMode(DataType left, DataType right) { |
424 | 18.4E | DCHECK(IsValid(left) && IsValid(right)) << left << ", " << right; |
425 | | |
426 | 733k | static const ConversionMode kID = ConversionMode::kIdentical; |
427 | 733k | static const ConversionMode kSI = ConversionMode::kSimilar; |
428 | 733k | static const ConversionMode kIM = ConversionMode::kImplicit; |
429 | 733k | static const ConversionMode kFC = ConversionMode::kFurtherCheck; |
430 | 733k | static const ConversionMode kEX = ConversionMode::kExplicit; |
431 | 733k | static const ConversionMode kNA = ConversionMode::kNotAllowed; |
432 | 733k | static const ConversionMode kConversionMode[kMaxTypeIndex][kMaxTypeIndex] = { |
433 | | // LHS := RHS (source) |
434 | | // nul | i8 | i16 | i32 | i64 | str | bln | flt | dbl | bin | tst | dec | vit | ine | lst | map | set | uid | tui | tup | arg | udt | frz | dat | tim | jso // NOLINT |
435 | 733k | /* nul */{ kID, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM, kIM }, // NOLINT |
436 | 733k | /* i8 */ { kIM, kID, kSI, kSI, kSI, kNA, kNA, kEX, kEX, kNA, kNA, kEX, kSI, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
437 | 733k | /* i16 */{ kIM, kSI, kID, kSI, kSI, kNA, kNA, kEX, kEX, kNA, kNA, kEX, kSI, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
438 | 733k | /* i32 */{ kIM, kSI, kSI, kID, kSI, kNA, kNA, kEX, kEX, kNA, kNA, kEX, kSI, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
439 | 733k | /* i64 */{ kIM, kSI, kSI, kSI, kID, kNA, kNA, kEX, kEX, kNA, kEX, kEX, kSI, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kEX, kEX, kNA }, // NOLINT |
440 | 733k | /* str */{ kIM, kEX, kEX, kEX, kEX, kID, kEX, kEX, kEX, kEX, kEX, kEX, kNA, kEX, kNA, kNA, kNA, kEX, kEX, kNA, kNA, kNA, kNA, kEX, kEX, kEX }, // NOLINT |
441 | 733k | /* bln */{ kIM, kNA, kNA, kNA, kNA, kNA, kID, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
442 | 733k | /* flt */{ kIM, kIM, kIM, kIM, kIM, kNA, kNA, kID, kSI, kNA, kNA, kSI, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
443 | 733k | /* dbl */{ kIM, kIM, kIM, kIM, kIM, kNA, kNA, kSI, kID, kNA, kNA, kSI, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
444 | 733k | /* bin */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kID, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
445 | 733k | /* tst */{ kIM, kNA, kNA, kNA, kIM, kIM, kNA, kNA, kNA, kNA, kID, kNA, kIM, kNA, kNA, kNA, kNA, kNA, kEX, kNA, kNA, kNA, kNA, kIM, kIM, kNA }, // NOLINT |
446 | 733k | /* dec */{ kIM, kIM, kIM, kIM, kIM, kEX, kNA, kSI, kSI, kNA, kEX, kID, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
447 | 733k | /* vit */{ kIM, kSI, kSI, kSI, kSI, kNA, kNA, kEX, kEX, kNA, kEX, kEX, kID, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kEX, kEX, kNA }, // NOLINT |
448 | 733k | /* ine */{ kIM, kNA, kNA, kNA, kNA, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kID, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
449 | 733k | /* lst */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kFC, kNA, kNA, kNA, kNA, kFC, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
450 | 733k | /* map */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kFC, kFC, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
451 | 733k | /* set */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kFC, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
452 | 733k | /* uid */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kID, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
453 | 733k | /* tui */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kIM, kID, kNA, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
454 | 733k | /* tup */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kFC, kNA, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
455 | 733k | /* arg */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kID, kNA, kNA, kNA, kNA, kNA }, // NOLINT |
456 | 733k | /* udt */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kFC, kNA, kNA, kNA, kNA, kNA, kFC, kNA, kNA, kNA, kNA }, // NOLINT |
457 | 733k | /* frz */{ kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kFC, kFC, kFC, kNA, kNA, kFC, kNA, kFC, kFC, kNA, kNA, kNA }, // NOLINT |
458 | 733k | /* dat */{ kIM, kNA, kNA, kNA, kIM, kIM, kNA, kNA, kNA, kNA, kIM, kNA, kIM, kNA, kNA, kNA, kNA, kNA, kEX, kNA, kNA, kNA, kNA, kID, kNA, kNA }, // NOLINT |
459 | 733k | /* tim */{ kIM, kNA, kNA, kNA, kIM, kIM, kNA, kNA, kNA, kNA, kIM, kNA, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kID, kNA }, // NOLINT |
460 | 733k | /* jso */{ kNA, kNA, kNA, kNA, kNA, kIM, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kNA, kID }, // NOLINT |
461 | 733k | }; |
462 | 733k | return kConversionMode[left][right]; |
463 | 733k | } |
464 | | |
465 | 229k | bool QLType::IsComparable(DataType left, DataType right) { |
466 | 18.4E | DCHECK(IsValid(left) && IsValid(right)) << left << ", " << right; |
467 | | |
468 | 229k | static const bool kYS = true; |
469 | 229k | static const bool kNO = false; |
470 | 229k | static const bool kCompareMode[kMaxTypeIndex][kMaxTypeIndex] = { |
471 | | // LHS == RHS (source) |
472 | | // nul | i8 | i16 | i32 | i64 | str | bln | flt | dbl | bin | tst | dec | vit | ine | lst | map | set | uid | tui | tup | arg | udt | frz | dat | tim | jso // NOLINT |
473 | 229k | /* nul */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
474 | 229k | /* i8 */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
475 | 229k | /* i16 */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
476 | 229k | /* i32 */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
477 | 229k | /* i64 */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
478 | 229k | /* str */{ kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
479 | 229k | /* bln */{ kNO, kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
480 | 229k | /* flt */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
481 | 229k | /* dbl */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
482 | 229k | /* bin */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
483 | 229k | /* tst */{ kNO, kNO, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kYS, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kYS, kNO }, // NOLINT |
484 | 229k | /* dec */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
485 | 229k | /* vit */{ kNO, kYS, kYS, kYS, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
486 | 229k | /* ine */{ kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
487 | 229k | /* lst */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
488 | 229k | /* map */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
489 | 229k | /* set */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
490 | 229k | /* uid */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
491 | 229k | /* tui */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
492 | 229k | /* tup */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
493 | 229k | /* arg */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
494 | 229k | /* udt */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO }, // NOLINT |
495 | 229k | /* frz */{ kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO }, // NOLINT |
496 | 229k | /* dat */{ kNO, kNO, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kYS, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kYS, kNO }, // NOLINT |
497 | 229k | /* tim */{ kNO, kNO, kNO, kNO, kYS, kYS, kNO, kNO, kNO, kNO, kYS, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS, kYS, kNO }, // NOLINT |
498 | 229k | /* jso */{ kNO, kNO, kNO, kNO, kNO, kYS, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kNO, kYS }, // NOLINT |
499 | 229k | }; |
500 | 229k | return kCompareMode[left][right]; |
501 | 229k | } |
502 | | |
503 | 432 | bool QLType::IsPotentiallyConvertible(DataType left, DataType right) { |
504 | 432 | return GetConversionMode(left, right) <= ConversionMode::kFurtherCheck; |
505 | 432 | } |
506 | | |
507 | 693 | bool QLType::IsSimilar(DataType left, DataType right) { |
508 | 693 | return GetConversionMode(left, right) <= ConversionMode::kSimilar; |
509 | 693 | } |
510 | | |
511 | 436 | boost::optional<size_t> QLType::GetUDTypeFieldIdxByName(const std::string &field_name) const { |
512 | 436 | const auto& field_names = udtype_field_names(); |
513 | 696 | for (size_t i = 0; i != field_names.size(); ++i260 ) { |
514 | 696 | if (field_names[i] == field_name) { |
515 | 436 | return i; |
516 | 436 | } |
517 | 696 | } |
518 | 0 | return boost::none; |
519 | 436 | } |
520 | | |
521 | | } // namespace yb |