/root/doris/be/src/vec/exprs/vexpr.h
Line | Count | Source (jump to first uncovered line) |
1 | | // Licensed to the Apache Software Foundation (ASF) under one |
2 | | // or more contributor license agreements. See the NOTICE file |
3 | | // distributed with this work for additional information |
4 | | // regarding copyright ownership. The ASF licenses this file |
5 | | // to you under the Apache License, Version 2.0 (the |
6 | | // "License"); you may not use this file except in compliance |
7 | | // with the License. You may obtain a copy of the License at |
8 | | // |
9 | | // http://www.apache.org/licenses/LICENSE-2.0 |
10 | | // |
11 | | // Unless required by applicable law or agreed to in writing, |
12 | | // software distributed under the License is distributed on an |
13 | | // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
14 | | // KIND, either express or implied. See the License for the |
15 | | // specific language governing permissions and limitations |
16 | | // under the License. |
17 | | |
18 | | #pragma once |
19 | | |
20 | | #include <gen_cpp/Exprs_types.h> |
21 | | #include <gen_cpp/Opcodes_types.h> |
22 | | #include <gen_cpp/Types_types.h> |
23 | | #include <glog/logging.h> |
24 | | |
25 | | #include <cstddef> |
26 | | #include <cstdint> |
27 | | #include <memory> |
28 | | #include <ostream> |
29 | | #include <string> |
30 | | #include <utility> |
31 | | #include <vector> |
32 | | |
33 | | #include "common/status.h" |
34 | | #include "olap/rowset/segment_v2/inverted_index_reader.h" |
35 | | #include "runtime/define_primitive_type.h" |
36 | | #include "runtime/large_int_value.h" |
37 | | #include "runtime/types.h" |
38 | | #include "udf/udf.h" |
39 | | #include "vec/aggregate_functions/aggregate_function.h" |
40 | | #include "vec/columns/column.h" |
41 | | #include "vec/core/block.h" |
42 | | #include "vec/core/column_with_type_and_name.h" |
43 | | #include "vec/core/types.h" |
44 | | #include "vec/core/wide_integer.h" |
45 | | #include "vec/data_types/data_type.h" |
46 | | #include "vec/data_types/data_type_ipv6.h" |
47 | | #include "vec/exprs/vexpr_fwd.h" |
48 | | #include "vec/functions/function.h" |
49 | | |
50 | | namespace doris { |
51 | | class BitmapFilterFuncBase; |
52 | | class BloomFilterFuncBase; |
53 | | class HybridSetBase; |
54 | | class ObjectPool; |
55 | | class RowDescriptor; |
56 | | class RuntimeState; |
57 | | |
58 | | namespace vectorized { |
59 | | #include "common/compile_check_begin.h" |
60 | | |
61 | | #define RETURN_IF_ERROR_OR_PREPARED(stmt) \ |
62 | 143 | if (_prepared) { \ |
63 | 0 | return Status::OK(); \ |
64 | 0 | } \ |
65 | 143 | _prepared = true; \ |
66 | 143 | RETURN_IF_ERROR(stmt); |
67 | | |
68 | | // VExpr should be used as shared pointer because it will be passed between classes |
69 | | // like runtime filter to scan node, or from scannode to scanner. We could not make sure |
70 | | // the relatioinship between threads and classes. |
71 | | class VExpr { |
72 | | public: |
73 | | // resize inserted param column to make sure column size equal to block.rows() and return param column index |
74 | | // keep return type same with block::columns() |
75 | 14 | static uint32_t insert_param(Block* block, ColumnWithTypeAndName&& elem, size_t size) { |
76 | | // usually elem.column always is const column, so we just clone it. |
77 | 14 | elem.column = elem.column->clone_resized(size); |
78 | 14 | block->insert(std::move(elem)); |
79 | | // just inserted. so no need to check underflow. |
80 | 14 | return block->columns() - 1; |
81 | 14 | } |
82 | | |
83 | | static bool is_acting_on_a_slot(const VExpr& expr); |
84 | | |
85 | | VExpr(const TExprNode& node); |
86 | | VExpr(const VExpr& vexpr); |
87 | | VExpr(TypeDescriptor type, bool is_slotref, bool is_nullable); |
88 | | // only used for test |
89 | 60 | VExpr() = default; |
90 | 326 | virtual ~VExpr() = default; |
91 | | |
92 | | virtual const std::string& expr_name() const = 0; |
93 | 0 | virtual std::string expr_label() { return ""; } |
94 | | |
95 | | /// Initializes this expr instance for execution. This does not include initializing |
96 | | /// state in the VExprContext; 'context' should only be used to register a |
97 | | /// FunctionContext via RegisterFunctionContext(). |
98 | | /// |
99 | | /// Subclasses overriding this function should call VExpr::Prepare() to recursively call |
100 | | /// Prepare() on the expr tree |
101 | | /// row_desc used in vslot_ref and some subclass to specify column |
102 | | virtual Status prepare(RuntimeState* state, const RowDescriptor& row_desc, |
103 | | VExprContext* context); |
104 | | |
105 | | /// Initializes 'context' for execution. If scope if FRAGMENT_LOCAL, both fragment- and |
106 | | /// thread-local state should be initialized. Otherwise, if scope is THREAD_LOCAL, only |
107 | | /// thread-local state should be initialized. |
108 | | // |
109 | | /// Subclasses overriding this function should call VExpr::Open() to recursively call |
110 | | /// Open() on the expr tree |
111 | | virtual Status open(RuntimeState* state, VExprContext* context, |
112 | | FunctionContext::FunctionStateScope scope); |
113 | | |
114 | | // before execute, check if expr has been parepared+opened. |
115 | 0 | [[maybe_unused]] Status ready_status() const { |
116 | 0 | if (_prepare_finished && _open_finished) { |
117 | 0 | return Status::OK(); |
118 | 0 | } |
119 | 0 | return Status::InternalError(expr_name() + " is not ready when execute"); |
120 | 0 | } |
121 | | |
122 | | virtual Status execute(VExprContext* context, Block* block, int* result_column_id) = 0; |
123 | | |
124 | | // execute current expr with inverted index to filter block. Given a roaring bitmap of match rows |
125 | 0 | virtual Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) { |
126 | 0 | return Status::OK(); |
127 | 0 | } |
128 | | |
129 | | Status _evaluate_inverted_index(VExprContext* context, const FunctionBasePtr& function, |
130 | | uint32_t segment_num_rows); |
131 | | |
132 | | virtual size_t estimate_memory(const size_t rows); |
133 | | |
134 | | // Only the 4th parameter is used in the runtime filter. In and MinMax need overwrite the |
135 | | // interface |
136 | | virtual Status execute_runtime_fitler(VExprContext* context, Block* block, |
137 | 0 | int* result_column_id, ColumnNumbers& args) { |
138 | 0 | return execute(context, block, result_column_id); |
139 | 0 | }; |
140 | | |
141 | | /// Subclasses overriding this function should call VExpr::Close(). |
142 | | // |
143 | | /// If scope if FRAGMENT_LOCAL, both fragment- and thread-local state should be torn |
144 | | /// down. Otherwise, if scope is THREAD_LOCAL, only thread-local state should be torn |
145 | | /// down. |
146 | | virtual void close(VExprContext* context, FunctionContext::FunctionStateScope scope); |
147 | | |
148 | 437 | DataTypePtr& data_type() { return _data_type; } |
149 | | |
150 | 151 | TypeDescriptor type() { return _type; } |
151 | | |
152 | 74 | bool is_slot_ref() const { return _node_type == TExprNodeType::SLOT_REF; } |
153 | | |
154 | 0 | bool is_column_ref() const { return _node_type == TExprNodeType::COLUMN_REF; } |
155 | | |
156 | 0 | virtual bool is_literal() const { return false; } |
157 | | |
158 | 102 | TExprNodeType::type node_type() const { return _node_type; } |
159 | | |
160 | 115 | TExprOpcode::type op() const { return _opcode; } |
161 | | |
162 | 110 | void add_child(const VExprSPtr& expr) { _children.push_back(expr); } |
163 | 0 | VExprSPtr get_child(uint16_t i) const { return _children[i]; } |
164 | | // Expr's children number is restricted by org.apache.doris.common.Config#expr_children_limit, 10000 default. and strongly not recommend to change. |
165 | | // There's little to worry about it. uint16 is enough. |
166 | 4 | uint16_t get_num_children() const { return static_cast<uint16_t>(_children.size()); } |
167 | | |
168 | 0 | virtual bool is_rf_wrapper() const { |
169 | 0 | return std::ranges::any_of(_children.begin(), _children.end(), |
170 | 0 | [](VExprSPtr child) { return child->is_rf_wrapper(); }); |
171 | 0 | } |
172 | | |
173 | 0 | virtual void do_judge_selectivity(uint64_t filter_rows, uint64_t input_rows) { |
174 | 0 | for (auto child : _children) { |
175 | 0 | child->do_judge_selectivity(filter_rows, input_rows); |
176 | 0 | } |
177 | 0 | } |
178 | | |
179 | | static Status create_expr_tree(const TExpr& texpr, VExprContextSPtr& ctx); |
180 | | |
181 | | static Status create_expr_trees(const std::vector<TExpr>& texprs, VExprContextSPtrs& ctxs); |
182 | | |
183 | | static Status prepare(const VExprContextSPtrs& ctxs, RuntimeState* state, |
184 | | const RowDescriptor& row_desc); |
185 | | |
186 | | static Status open(const VExprContextSPtrs& ctxs, RuntimeState* state); |
187 | | |
188 | | static Status clone_if_not_exists(const VExprContextSPtrs& ctxs, RuntimeState* state, |
189 | | VExprContextSPtrs& new_ctxs); |
190 | | |
191 | 3 | bool is_nullable() const { return _data_type->is_nullable(); } |
192 | | |
193 | 0 | PrimitiveType result_type() const { return _type.type; } |
194 | | |
195 | | static Status create_expr(const TExprNode& expr_node, VExprSPtr& expr); |
196 | | |
197 | | static Status create_tree_from_thrift(const std::vector<TExprNode>& nodes, int* node_idx, |
198 | | VExprSPtr& root_expr, VExprContextSPtr& ctx); |
199 | | |
200 | | static Status check_expr_output_type(const VExprContextSPtrs& ctxs, |
201 | | const RowDescriptor& output_row_desc); |
202 | 581 | virtual const VExprSPtrs& children() const { return _children; } |
203 | 0 | void set_children(const VExprSPtrs& children) { _children = children; } |
204 | 0 | void set_children(VExprSPtrs&& children) { _children = std::move(children); } |
205 | | virtual std::string debug_string() const; |
206 | | static std::string debug_string(const VExprSPtrs& exprs); |
207 | | static std::string debug_string(const VExprContextSPtrs& ctxs); |
208 | | |
209 | 0 | void set_getting_const_col(bool val = true) { _getting_const_col = val; } |
210 | | |
211 | 0 | bool is_and_expr() const { return _fn.name.function_name == "and"; } |
212 | | |
213 | 0 | virtual bool is_compound_predicate() const { return false; } |
214 | | |
215 | 10 | const TFunction& fn() const { return _fn; } |
216 | | |
217 | | /// Returns true if expr doesn't contain slotrefs, i.e., can be evaluated |
218 | | /// with get_value(NULL). The default implementation returns true if all of |
219 | | /// the children are constant. |
220 | | virtual bool is_constant() const; |
221 | | |
222 | | /// If this expr is constant, evaluates the expr with no input row argument and returns |
223 | | /// the output. Returns nullptr if the argument is not constant. The returned ColumnPtr is |
224 | | /// owned by this expr. This should only be called after Open() has been called on this |
225 | | /// expr. |
226 | | Status get_const_col(VExprContext* context, std::shared_ptr<ColumnPtrWrapper>* column_wrapper); |
227 | | |
228 | 0 | int fn_context_index() const { return _fn_context_index; } |
229 | | |
230 | 0 | static VExprSPtr expr_without_cast(const VExprSPtr& expr) { |
231 | 0 | if (expr->node_type() == TExprNodeType::CAST_EXPR) { |
232 | 0 | return expr_without_cast(expr->_children[0]); |
233 | 0 | } |
234 | 0 | return expr; |
235 | 0 | } |
236 | | |
237 | | // If this expr is a RuntimeFilterWrapper, this method will return an underlying rf expression |
238 | 0 | virtual VExprSPtr get_impl() const { return {}; } |
239 | | |
240 | | // If this expr is a BloomPredicate, this method will return a BloomFilterFunc |
241 | 0 | virtual std::shared_ptr<BloomFilterFuncBase> get_bloom_filter_func() const { |
242 | 0 | throw Exception(Status::FatalError( |
243 | 0 | "Method 'get_bloom_filter_func()' is not supported in expression: {}", |
244 | 0 | this->debug_string())); |
245 | 0 | } |
246 | | |
247 | 0 | virtual std::shared_ptr<HybridSetBase> get_set_func() const { return nullptr; } |
248 | | |
249 | | // If this expr is a BitmapPredicate, this method will return a BitmapFilterFunc |
250 | 0 | virtual std::shared_ptr<BitmapFilterFuncBase> get_bitmap_filter_func() const { |
251 | 0 | throw Exception(Status::FatalError( |
252 | 0 | "Method 'get_bitmap_filter_func()' is not supported in expression: {}", |
253 | 0 | this->debug_string())); |
254 | 0 | } |
255 | | |
256 | | // fast_execute can direct copy expr filter result which build by apply index in segment_iterator |
257 | | bool fast_execute(doris::vectorized::VExprContext* context, doris::vectorized::Block* block, |
258 | | int* result_column_id); |
259 | | |
260 | 0 | virtual bool can_push_down_to_index() const { return false; } |
261 | | virtual bool equals(const VExpr& other); |
262 | 0 | void set_index_unique_id(uint32_t index_unique_id) { _index_unique_id = index_unique_id; } |
263 | 0 | uint32_t index_unique_id() const { return _index_unique_id; } |
264 | | |
265 | | protected: |
266 | | /// Simple debug string that provides no expr subclass-specific information |
267 | 0 | std::string debug_string(const std::string& expr_name) const { |
268 | 0 | std::stringstream out; |
269 | 0 | out << expr_name << "(" << VExpr::debug_string() << ")"; |
270 | 0 | return out.str(); |
271 | 0 | } |
272 | | |
273 | 65 | std::string get_child_names() { |
274 | 65 | std::string res; |
275 | 89 | for (auto child : _children) { |
276 | 89 | if (!res.empty()) { |
277 | 42 | res += ", "; |
278 | 42 | } |
279 | 89 | res += child->expr_name(); |
280 | 89 | } |
281 | 65 | return res; |
282 | 65 | } |
283 | | |
284 | 0 | bool is_const_and_have_executed() { return (is_constant() && (_constant_col != nullptr)); } |
285 | | |
286 | | Status get_result_from_const(vectorized::Block* block, const std::string& expr_name, |
287 | | int* result_column_id); |
288 | | |
289 | | Status check_constant(const Block& block, ColumnNumbers arguments) const; |
290 | | |
291 | | /// Helper function that calls ctx->register(), sets fn_context_index_, and returns the |
292 | | /// registered FunctionContext |
293 | | void register_function_context(RuntimeState* state, VExprContext* context); |
294 | | |
295 | | /// Helper function to initialize function context, called in `open` phase of VExpr: |
296 | | /// 1. Set constant columns result of function arguments. |
297 | | /// 2. Call function's prepare() to initialize function state, fragment-local or |
298 | | /// thread-local according the input `FunctionStateScope` argument. |
299 | | Status init_function_context(RuntimeState* state, VExprContext* context, |
300 | | FunctionContext::FunctionStateScope scope, |
301 | | const FunctionBasePtr& function) const; |
302 | | |
303 | | /// Helper function to close function context, fragment-local or thread-local according |
304 | | /// the input `FunctionStateScope` argument. Called in `close` phase of VExpr. |
305 | | void close_function_context(VExprContext* context, FunctionContext::FunctionStateScope scope, |
306 | | const FunctionBasePtr& function) const; |
307 | | |
308 | | TExprNodeType::type _node_type; |
309 | | // Used to check what opcode |
310 | | TExprOpcode::type _opcode; |
311 | | TypeDescriptor _type; |
312 | | DataTypePtr _data_type; |
313 | | VExprSPtrs _children; // in few hundreds |
314 | | TFunction _fn; |
315 | | |
316 | | /// Index to pass to ExprContext::fn_context() to retrieve this expr's FunctionContext. |
317 | | /// Set in RegisterFunctionContext(). -1 if this expr does not need a FunctionContext and |
318 | | /// doesn't call RegisterFunctionContext(). |
319 | | int _fn_context_index = -1; |
320 | | |
321 | | // If this expr is constant, this will store and cache the value generated by |
322 | | // get_const_col() |
323 | | std::shared_ptr<ColumnPtrWrapper> _constant_col; |
324 | | bool _prepared = false; // for base class VExpr |
325 | | bool _getting_const_col = |
326 | | false; // if true, current execute() is in prepare() (that is, can't check _prepared) |
327 | | // for concrete classes |
328 | | bool _prepare_finished = false; |
329 | | bool _open_finished = false; |
330 | | |
331 | | // ensuring uniqueness during index traversal |
332 | | uint32_t _index_unique_id = 0; |
333 | | bool _enable_inverted_index_query = true; |
334 | | }; |
335 | | |
336 | | } // namespace vectorized |
337 | | |
338 | | // NOLINTBEGIN(readability-function-size) |
339 | | template <PrimitiveType T> |
340 | | Status create_texpr_literal_node(const void* data, TExprNode* node, int precision = 0, |
341 | 0 | int scale = 0) { |
342 | 0 | if constexpr (T == TYPE_BOOLEAN) { |
343 | 0 | const auto* origin_value = reinterpret_cast<const bool*>(data); |
344 | 0 | TBoolLiteral boolLiteral; |
345 | 0 | (*node).__set_node_type(TExprNodeType::BOOL_LITERAL); |
346 | 0 | boolLiteral.__set_value(*origin_value); |
347 | 0 | (*node).__set_bool_literal(boolLiteral); |
348 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_BOOLEAN)); |
349 | 0 | } else if constexpr (T == TYPE_TINYINT) { |
350 | 0 | const auto* origin_value = reinterpret_cast<const int8_t*>(data); |
351 | 0 | (*node).__set_node_type(TExprNodeType::INT_LITERAL); |
352 | 0 | TIntLiteral intLiteral; |
353 | 0 | intLiteral.__set_value(*origin_value); |
354 | 0 | (*node).__set_int_literal(intLiteral); |
355 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_TINYINT)); |
356 | 0 | } else if constexpr (T == TYPE_SMALLINT) { |
357 | 0 | const auto* origin_value = reinterpret_cast<const int16_t*>(data); |
358 | 0 | (*node).__set_node_type(TExprNodeType::INT_LITERAL); |
359 | 0 | TIntLiteral intLiteral; |
360 | 0 | intLiteral.__set_value(*origin_value); |
361 | 0 | (*node).__set_int_literal(intLiteral); |
362 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_SMALLINT)); |
363 | 0 | } else if constexpr (T == TYPE_INT) { |
364 | 0 | const auto* origin_value = reinterpret_cast<const int32_t*>(data); |
365 | 0 | (*node).__set_node_type(TExprNodeType::INT_LITERAL); |
366 | 0 | TIntLiteral intLiteral; |
367 | 0 | intLiteral.__set_value(*origin_value); |
368 | 0 | (*node).__set_int_literal(intLiteral); |
369 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_INT)); |
370 | 0 | } else if constexpr (T == TYPE_BIGINT) { |
371 | 0 | const auto* origin_value = reinterpret_cast<const int64_t*>(data); |
372 | 0 | (*node).__set_node_type(TExprNodeType::INT_LITERAL); |
373 | 0 | TIntLiteral intLiteral; |
374 | 0 | intLiteral.__set_value(*origin_value); |
375 | 0 | (*node).__set_int_literal(intLiteral); |
376 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_BIGINT)); |
377 | 0 | } else if constexpr (T == TYPE_LARGEINT) { |
378 | 0 | const auto* origin_value = reinterpret_cast<const int128_t*>(data); |
379 | 0 | (*node).__set_node_type(TExprNodeType::LARGE_INT_LITERAL); |
380 | 0 | TLargeIntLiteral large_int_literal; |
381 | 0 | large_int_literal.__set_value(LargeIntValue::to_string(*origin_value)); |
382 | 0 | (*node).__set_large_int_literal(large_int_literal); |
383 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_LARGEINT)); |
384 | 0 | } else if constexpr ((T == TYPE_DATE) || (T == TYPE_DATETIME) || (T == TYPE_TIMEV2)) { |
385 | 0 | const auto* origin_value = reinterpret_cast<const VecDateTimeValue*>(data); |
386 | 0 | TDateLiteral date_literal; |
387 | 0 | char convert_buffer[30]; |
388 | 0 | origin_value->to_string(convert_buffer); |
389 | 0 | date_literal.__set_value(convert_buffer); |
390 | 0 | (*node).__set_date_literal(date_literal); |
391 | 0 | (*node).__set_node_type(TExprNodeType::DATE_LITERAL); |
392 | 0 | if (origin_value->type() == TimeType::TIME_DATE) { |
393 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATE)); |
394 | 0 | } else if (origin_value->type() == TimeType::TIME_DATETIME) { |
395 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATETIME)); |
396 | 0 | } else if (origin_value->type() == TimeType::TIME_TIME) { |
397 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_TIMEV2)); |
398 | 0 | } |
399 | 0 | } else if constexpr (T == TYPE_DATEV2) { |
400 | 0 | const auto* origin_value = reinterpret_cast<const DateV2Value<DateV2ValueType>*>(data); |
401 | 0 | TDateLiteral date_literal; |
402 | 0 | char convert_buffer[30]; |
403 | 0 | origin_value->to_string(convert_buffer); |
404 | 0 | date_literal.__set_value(convert_buffer); |
405 | 0 | (*node).__set_date_literal(date_literal); |
406 | 0 | (*node).__set_node_type(TExprNodeType::DATE_LITERAL); |
407 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATEV2)); |
408 | 0 | } else if constexpr (T == TYPE_DATETIMEV2) { |
409 | 0 | const auto* origin_value = reinterpret_cast<const DateV2Value<DateTimeV2ValueType>*>(data); |
410 | 0 | TDateLiteral date_literal; |
411 | 0 | char convert_buffer[30]; |
412 | 0 | origin_value->to_string(convert_buffer, scale); |
413 | 0 | date_literal.__set_value(convert_buffer); |
414 | 0 | (*node).__set_date_literal(date_literal); |
415 | 0 | (*node).__set_node_type(TExprNodeType::DATE_LITERAL); |
416 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATETIMEV2, precision, scale)); |
417 | 0 | } else if constexpr (T == TYPE_DECIMALV2) { |
418 | 0 | const auto* origin_value = reinterpret_cast<const DecimalV2Value*>(data); |
419 | 0 | (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL); |
420 | 0 | TDecimalLiteral decimal_literal; |
421 | 0 | decimal_literal.__set_value(origin_value->to_string()); |
422 | 0 | (*node).__set_decimal_literal(decimal_literal); |
423 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMALV2, precision, scale)); |
424 | 0 | } else if constexpr (T == TYPE_DECIMAL32) { |
425 | 0 | const auto* origin_value = reinterpret_cast<const vectorized::Decimal<int32_t>*>(data); |
426 | 0 | (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL); |
427 | 0 | TDecimalLiteral decimal_literal; |
428 | 0 | decimal_literal.__set_value(origin_value->to_string(precision, scale)); |
429 | 0 | (*node).__set_decimal_literal(decimal_literal); |
430 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL32, precision, scale)); |
431 | 0 | } else if constexpr (T == TYPE_DECIMAL64) { |
432 | 0 | const auto* origin_value = reinterpret_cast<const vectorized::Decimal<int64_t>*>(data); |
433 | 0 | (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL); |
434 | 0 | TDecimalLiteral decimal_literal; |
435 | 0 | decimal_literal.__set_value(origin_value->to_string(precision, scale)); |
436 | 0 | (*node).__set_decimal_literal(decimal_literal); |
437 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL64, precision, scale)); |
438 | 0 | } else if constexpr (T == TYPE_DECIMAL128I) { |
439 | 0 | const auto* origin_value = reinterpret_cast<const vectorized::Decimal<int128_t>*>(data); |
440 | 0 | (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL); |
441 | 0 | TDecimalLiteral decimal_literal; |
442 | | // e.g. For a decimal(26,6) column, the initial value of the _min of the MinMax RF |
443 | | // on the RF producer side is an int128 value with 38 digits of 9, and this is the |
444 | | // final min value of the MinMax RF if the fragment instance has no data. |
445 | | // Need to truncate the value to the right precision and scale here, to avoid |
446 | | // error when casting string back to decimal later. |
447 | | // TODO: this is a temporary solution, the best solution is to produce the |
448 | | // right min max value at the producer side. |
449 | 0 | decimal_literal.__set_value(origin_value->to_string(precision, scale)); |
450 | 0 | (*node).__set_decimal_literal(decimal_literal); |
451 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL128I, precision, scale)); |
452 | 0 | } else if constexpr (T == TYPE_DECIMAL256) { |
453 | 0 | const auto* origin_value = reinterpret_cast<const vectorized::Decimal<wide::Int256>*>(data); |
454 | 0 | (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL); |
455 | 0 | TDecimalLiteral decimal_literal; |
456 | 0 | decimal_literal.__set_value(origin_value->to_string(precision, scale)); |
457 | 0 | (*node).__set_decimal_literal(decimal_literal); |
458 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL256, precision, scale)); |
459 | 0 | } else if constexpr (T == TYPE_FLOAT) { |
460 | 0 | const auto* origin_value = reinterpret_cast<const float*>(data); |
461 | 0 | (*node).__set_node_type(TExprNodeType::FLOAT_LITERAL); |
462 | 0 | TFloatLiteral float_literal; |
463 | 0 | float_literal.__set_value(*origin_value); |
464 | 0 | (*node).__set_float_literal(float_literal); |
465 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_FLOAT)); |
466 | 0 | } else if constexpr (T == TYPE_DOUBLE) { |
467 | 0 | const auto* origin_value = reinterpret_cast<const double*>(data); |
468 | 0 | (*node).__set_node_type(TExprNodeType::FLOAT_LITERAL); |
469 | 0 | TFloatLiteral float_literal; |
470 | 0 | float_literal.__set_value(*origin_value); |
471 | 0 | (*node).__set_float_literal(float_literal); |
472 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DOUBLE)); |
473 | 0 | } else if constexpr ((T == TYPE_STRING) || (T == TYPE_CHAR) || (T == TYPE_VARCHAR)) { |
474 | 0 | const auto* origin_value = reinterpret_cast<const std::string*>(data); |
475 | 0 | (*node).__set_node_type(TExprNodeType::STRING_LITERAL); |
476 | 0 | TStringLiteral string_literal; |
477 | 0 | string_literal.__set_value(*origin_value); |
478 | 0 | (*node).__set_string_literal(string_literal); |
479 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_STRING)); |
480 | 0 | } else if constexpr (T == TYPE_IPV4) { |
481 | 0 | const auto* origin_value = reinterpret_cast<const IPv4*>(data); |
482 | 0 | (*node).__set_node_type(TExprNodeType::IPV4_LITERAL); |
483 | 0 | TIPv4Literal literal; |
484 | 0 | literal.__set_value(*origin_value); |
485 | 0 | (*node).__set_ipv4_literal(literal); |
486 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_IPV4)); |
487 | 0 | } else if constexpr (T == TYPE_IPV6) { |
488 | 0 | const auto* origin_value = reinterpret_cast<const IPv6*>(data); |
489 | 0 | (*node).__set_node_type(TExprNodeType::IPV6_LITERAL); |
490 | 0 | TIPv6Literal literal; |
491 | 0 | literal.__set_value(vectorized::DataTypeIPv6::to_string(*origin_value)); |
492 | 0 | (*node).__set_ipv6_literal(literal); |
493 | 0 | (*node).__set_type(create_type_desc(PrimitiveType::TYPE_IPV6)); |
494 | 0 | } else { |
495 | 0 | return Status::InvalidArgument("Invalid argument type!"); |
496 | 0 | } |
497 | 0 | return Status::OK(); |
498 | 0 | } Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE2EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE3EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE4EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE5EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE6EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE7EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE8EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE9EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE25EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE26EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE11EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE12EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE20EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE28EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE29EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE30EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE35EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE15EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE10EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE23EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE36EEENS_6StatusEPKvPNS_9TExprNodeEii Unexecuted instantiation: _ZN5doris25create_texpr_literal_nodeILNS_13PrimitiveTypeE37EEENS_6StatusEPKvPNS_9TExprNodeEii |
499 | | // NOLINTEND(readability-function-size) |
500 | | |
501 | | TExprNode create_texpr_node_from(const void* data, const PrimitiveType& type, int precision = 0, |
502 | | int scale = 0); |
503 | | |
504 | | #include "common/compile_check_end.h" |
505 | | } // namespace doris |