Coverage Report

Created: 2025-03-13 18:54

/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