be/src/exprs/vexpr.h

Source
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#pragma once

#include <gen_cpp/Exprs_types.h>
#include <gen_cpp/Opcodes_types.h>
#include <gen_cpp/Types_types.h>
#include <glog/logging.h>

#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <utility>
#include <vector>

#include "common/be_mock_util.h"
#include "common/status.h"
#include "core/block/block.h"
#include "core/block/column_with_type_and_name.h"
#include "core/column/column.h"
#include "core/data_type/data_type.h"
#include "core/data_type/data_type_ipv6.h"
#include "core/data_type/define_primitive_type.h"
#include "core/extended_types.h"
#include "core/string_view.h"
#include "core/types.h"
#include "core/value/large_int_value.h"
#include "core/value/timestamptz_value.h"
#include "exprs/aggregate/aggregate_function.h"
#include "exprs/expr_zonemap_filter.h"
#include "exprs/function/cast/cast_to_string.h"
#include "exprs/function/function.h"
#include "exprs/function_context.h"
#include "exprs/vexpr_fwd.h"
#include "storage/index/ann/ann_search_params.h"
#include "storage/index/index_reader.h"
#include "storage/index/inverted/inverted_index_reader.h"
#include "storage/index/zone_map/zonemap_filter_result.h"
#include "util/date_func.h"
#include "util/unaligned.h"

namespace doris {
class BloomFilterFuncBase;
class HybridSetBase;
class ObjectPool;
class RowDescriptor;
class RuntimeState;
class ZoneMapEvalContext;

namespace segment_v2 {
class IndexIterator;
class ColumnIterator;
struct AnnRangeSearchRuntime;
}; // namespace segment_v2

#define RETURN_IF_ERROR_OR_PREPARED(stmt) \
    if (_prepared) {                      \
        return Status::OK();              \
    }                                     \
    _prepared = true;                     \
    RETURN_IF_ERROR(stmt);

// VExpr should be used as shared pointer because it will be passed between classes
// like runtime filter to scan node, or from scannode to scanner. We could not make sure
// the relatioinship between threads and classes.

using Selector = IColumn::Selector;
using VExprCloneNodeOverride = std::function<Status(const VExpr&, VExprSPtr*)>;

struct AnnRangeSearchEvaluationResult {
    // Indicates whether the expr row_bitmap has been updated.
    bool executed = false;
    // Indicates whether the virtual column is fulfilled.
    // NOTE, if there is no virtual column in the expr tree, and expr
    // is evaluated by ann index, this flag is still true.
    bool dist_fulfilled = false;
};

class VExpr {
public:
    // resize inserted param column to make sure column size equal to block.rows() and return param column index
    // keep return type same with block::columns()
    static uint32_t insert_param(Block* block, ColumnWithTypeAndName&& elem, size_t size) {
        // usually elem.column always is const column, so we just clone it.
        elem.column = elem.column->clone_resized(size);
        block->insert(std::move(elem));
        // just inserted. so no need to check underflow.
        return block->columns() - 1;
    }

    VExpr(const TExprNode& node);
    VExpr(const VExpr& vexpr);
    VExpr(DataTypePtr type, bool is_slotref);
    // only used for test
    VExpr() = default;
    virtual ~VExpr() = default;

    virtual const std::string& expr_name() const = 0;
    virtual std::string expr_label() { return ""; }

    /// Initializes this expr instance for execution. This does not include initializing
    /// state in the VExprContext; 'context' should only be used to register a
    /// FunctionContext via RegisterFunctionContext().
    ///
    /// Subclasses overriding this function should call VExpr::Prepare() to recursively call
    /// Prepare() on the expr tree
    /// row_desc used in vslot_ref and some subclass to specify column
    virtual Status prepare(RuntimeState* state, const RowDescriptor& row_desc,
                           VExprContext* context);

    /// Initializes 'context' for execution. If scope if FRAGMENT_LOCAL, both fragment- and
    /// thread-local state should be initialized. Otherwise, if scope is THREAD_LOCAL, only
    /// thread-local state should be initialized.
    //
    /// Subclasses overriding this function should call VExpr::Open() to recursively call
    /// Open() on the expr tree
    virtual Status open(RuntimeState* state, VExprContext* context,
                        FunctionContext::FunctionStateScope scope);

    // before execute, check if expr has been parepared+opened.
    [[maybe_unused]] Status ready_status() const {
        if (_prepare_finished && _open_finished) {
            return Status::OK();
        }
        return Status::InternalError(expr_name() + " is not ready when execute");
    }

    virtual Status execute(VExprContext* context, Block* block, int* result_column_id) const {
        ColumnPtr result_column;
        RETURN_IF_ERROR(execute_column(context, block, nullptr, block->rows(), result_column));
        *result_column_id = block->columns();
        block->insert({result_column, execute_type(block), expr_name()});
        return Status::OK();
    }

    // Execute the current expression and return the result column.
    // Note: the block will not be modified during execution.
    // We allow columns in the block to have different numbers of rows.
    // 'count' indicates the number of rows in the result column returned by this expression.
    // In the future this interface will add an additional parameter, Selector, which specifies
    // which rows in the block should be evaluated.
    // If expr is executing constant expressions, then block should be nullptr.

    Status execute_column(VExprContext* context, const Block* block, const Selector* selector,
                          size_t count, ColumnPtr& result_column) const;

    virtual Status execute_column_impl(VExprContext* context, const Block* block,
                                       const Selector* selector, size_t count,
                                       ColumnPtr& result_column) const = 0;

    // Currently, due to fe planning issues, for slot-ref expressions the type of the returned Column may not match data_type.
    // Therefore we need a function like this to return the actual type produced by execution.
    virtual DataTypePtr execute_type(const Block* block) const { return _data_type; }

    virtual Status execute_filter(VExprContext* context, const Block* block,
                                  uint8_t* __restrict result_filter_data, size_t rows,
                                  bool accept_null, bool* can_filter_all) const;

    // Raw fixed-width evaluation is an optional expression capability used before a storage reader
    // materializes a column. `matches` is ANDed in place; callers handle NULL rows separately
    // because raw value streams contain only non-NULL payloads.
    virtual bool can_execute_on_raw_fixed_values(const DataTypePtr& data_type,
                                                 int column_id) const {
        return false;
    }
    virtual Status execute_on_raw_fixed_values(const uint8_t* values, size_t num_values,
                                               size_t value_width, const DataTypePtr& data_type,
                                               int column_id, uint8_t* matches) const {
        return Status::NotSupported("{} cannot evaluate raw fixed-width values", expr_name());
    }

    // `is_blockable` means this expr will be blocked in `execute` (e.g. AI Function, Remote Function)
    [[nodiscard]] virtual bool is_blockable() const {
        return std::any_of(_children.begin(), _children.end(),
                           [](VExprSPtr child) { return child->is_blockable(); });
    }

    [[nodiscard]] virtual bool is_deterministic() const {
        return std::ranges::all_of(
                _children, [](const VExprSPtr& child) { return child->is_deterministic(); });
    }

    [[nodiscard]] virtual bool is_safe_to_execute_on_selected_rows() const {
        return is_deterministic() && std::ranges::all_of(_children, [](const VExprSPtr& child) {
                   return child->is_safe_to_execute_on_selected_rows();
               });
    }

    // execute current expr with inverted index to filter block. Given a roaring bitmap of match rows
    virtual Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) {
        return Status::OK();
    }

    virtual ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const;
    virtual bool can_evaluate_zonemap_filter() const { return false; }
    virtual ZoneMapFilterResult evaluate_dictionary_filter(const DictionaryEvalContext& ctx) const;
    virtual bool can_evaluate_dictionary_filter() const { return false; }
    virtual ZoneMapFilterResult evaluate_bloom_filter(const BloomFilterEvalContext& ctx) const;
    virtual bool can_evaluate_bloom_filter() const { return false; }

    // Get analyzer key for inverted index queries (overridden by VMatchPredicate)
    [[nodiscard]] virtual const std::string& get_analyzer_key() const {
        static const std::string empty;
        return empty;
    }

    Status _evaluate_inverted_index(VExprContext* context, const FunctionBasePtr& function,
                                    uint32_t segment_num_rows);

    virtual size_t estimate_memory(const size_t rows);

    // Only the 4th parameter is used in the runtime filter. In and MinMax need overwrite the
    // interface
    virtual Status execute_runtime_filter(VExprContext* context, const Block* block,
                                          const uint8_t* __restrict filter, size_t count,
                                          ColumnPtr& result_column, ColumnPtr* arg_column) const {
        return execute_column(context, block, nullptr, count, result_column);
    };

    /// Subclasses overriding this function should call VExpr::Close().
    //
    /// If scope if FRAGMENT_LOCAL, both fragment- and thread-local state should be torn
    /// down. Otherwise, if scope is THREAD_LOCAL, only thread-local state should be torn
    /// down.
    virtual void close(VExprContext* context, FunctionContext::FunctionStateScope scope);

    DataTypePtr& data_type() { return _data_type; }

    const DataTypePtr& data_type() const { return _data_type; }

    virtual bool is_slot_ref() const { return _node_type == TExprNodeType::SLOT_REF; }

    virtual bool is_virtual_slot_ref() const {
        return _node_type == TExprNodeType::VIRTUAL_SLOT_REF;
    }

    virtual bool is_column_ref() const { return _node_type == TExprNodeType::COLUMN_REF; }

    virtual bool is_literal() const { return false; }

    virtual TExprNodeType::type node_type() const { return _node_type; }

    TExprOpcode::type op() const { return _opcode; }

    // Planner verdict for dict-filtering this node as a conjunct root; std::nullopt if the
    // FE did not stamp it. See can_push_down_to_dict_filter.
    std::optional<bool> can_dict_filter_from_planner() const {
        return _can_dict_filter_from_planner;
    }

    void add_child(const VExprSPtr& expr) { _children.push_back(expr); }
    VExprSPtr get_child(uint16_t i) const { return _children[i]; }
    // Expr's children number is restricted by org.apache.doris.common.Config#expr_children_limit, 10000 default. and strongly not recommend to change.
    // There's little to worry about it. uint16 is enough.
    uint16_t get_num_children() const { return static_cast<uint16_t>(_children.size()); }

    virtual bool is_rf_wrapper() const {
        return std::ranges::any_of(_children.begin(), _children.end(),
                                   [](VExprSPtr child) { return child->is_rf_wrapper(); });
    }
    virtual bool is_topn_filter() const { return false; }

    static Status create_expr_tree(const TExpr& texpr, VExprContextSPtr& ctx);

    static Status create_expr_trees(const std::vector<TExpr>& texprs, VExprContextSPtrs& ctxs);

    static Status prepare(const VExprContextSPtrs& ctxs, RuntimeState* state,
                          const RowDescriptor& row_desc);

    static Status open(const VExprContextSPtrs& ctxs, RuntimeState* state);

    static Status clone_if_not_exists(const VExprContextSPtrs& ctxs, RuntimeState* state,
                                      VExprContextSPtrs& new_ctxs);

    static bool contains_blockable_function(const VExprContextSPtrs& ctxs);

    // Whether a single-slot filter conjunct rooted at `root` can be evaluated on a
    // column's dictionary (distinct values) instead of per row. This lets an ORC/Parquet
    // scan run a heavy string predicate such as `split_by_string(col, sep)[n] = 'x'` once
    // per distinct value rather than once per row. Requirements (all must hold):
    //   - root is a BINARY_PRED or IN_PRED whose non-literal side is derived from a
    //     single slot equal to `slot_id`;
    //   - that side is a deterministic, NULL-insensitive scalar expression over the slot.
    // NULL-sensitive predicates (is null / coalesce / ...) are rejected because the
    // dictionary carries no NULL entry; non-deterministic functions (rand / uuid / ...)
    // are rejected because each distinct value is evaluated only once and cached.
    // When allow_expr is false, only the original form (a bare column ref compared to
    // constants) is accepted, so a session variable can disable the expression case.
    static bool can_push_down_to_dict_filter(const VExprSPtr& root, int slot_id, bool allow_expr);

    Status deep_clone(VExprSPtr* cloned_expr,
                      const VExprCloneNodeOverride& clone_node_override = {}) const;
    virtual Status clone_node(VExprSPtr* cloned_expr) const;

    bool is_nullable() const { return _data_type->is_nullable(); }

    PrimitiveType result_type() const { return _data_type->get_primitive_type(); }

    static Status create_expr(const TExprNode& expr_node, VExprSPtr& expr);

    static Status create_tree_from_thrift(const std::vector<TExprNode>& nodes, int* node_idx,
                                          VExprSPtr& root_expr, VExprContextSPtr& ctx);

    static Status check_expr_output_type(const VExprContextSPtrs& ctxs,
                                         const RowDescriptor& output_row_desc);
    virtual const VExprSPtrs& children() const { return _children; }
    void set_children(const VExprSPtrs& children) { _children = children; }
    void set_children(VExprSPtrs&& children) { _children = std::move(children); }
    void reset_prepare_state();
    virtual std::string debug_string() const;
    static std::string debug_string(const VExprSPtrs& exprs);
    static std::string debug_string(const VExprContextSPtrs& ctxs);

    static ColumnPtr filter_column_with_selector(const ColumnPtr& origin_column,
                                                 const Selector* selector, size_t count) {
        if (selector == nullptr) {
            DCHECK_EQ(origin_column->size(), count) << origin_column->get_name();
            return origin_column;
        }
        DCHECK_EQ(count, selector->size());
        auto mutable_column = origin_column->clone_empty();
        origin_column->append_data_by_selector(mutable_column, *selector);
        DCHECK_EQ(mutable_column->size(), count);
        return mutable_column;
    }

    bool is_and_expr() const { return _fn.name.function_name == "and"; }
    bool is_like_expr() const { return _fn.name.function_name == "like"; }

    const TFunction& fn() const { return _fn; }

    /// Returns true if expr doesn't contain slotrefs, i.e., can be evaluated
    /// with get_value(NULL). The default implementation returns true if all of
    /// the children are constant.
    virtual bool is_constant() const;

    /// If this expr is constant, evaluates the expr with no input row argument and returns
    /// the output. Returns nullptr if the argument is not constant. The returned ColumnPtr is
    /// owned by this expr. This should only be called after Open() has been called on this
    /// expr.
    MOCK_FUNCTION Status get_const_col(VExprContext* context,
                                       std::shared_ptr<ColumnPtrWrapper>* column_wrapper);

    int fn_context_index() const { return _fn_context_index; }

    static VExprSPtr expr_without_cast(const VExprSPtr& expr) {
        if (expr->node_type() == TExprNodeType::CAST_EXPR) {
            return expr_without_cast(expr->_children[0]);
        }
        return expr;
    }

    virtual double execute_cost() const {
        double cost = 1.0;
        for (const auto& child : _children) {
            cost += child->execute_cost();
        }
        return cost;
    }

    // If this expr is a RuntimeFilterWrapper, this method will return an underlying rf expression
    virtual VExprSPtr get_impl() const { return {}; }

    // If this expr is a BloomPredicate, this method will return a BloomFilterFunc
    virtual std::shared_ptr<BloomFilterFuncBase> get_bloom_filter_func() const {
        throw Exception(Status::FatalError(
                "Method 'get_bloom_filter_func()' is not supported in expression: {}",
                this->debug_string()));
    }

    virtual std::shared_ptr<HybridSetBase> get_set_func() const { return nullptr; }

    // fast_execute can direct copy expr filter result which build by apply index in segment_iterator
    bool fast_execute(VExprContext* context, const Selector* selector, size_t count,
                      ColumnPtr& result_column) const;

    virtual bool can_push_down_to_index() const { return false; }
    virtual bool equals(const VExpr& other);
    void set_index_unique_id(uint32_t index_unique_id) { _index_unique_id = index_unique_id; }
    uint32_t index_unique_id() const { return _index_unique_id; }

    virtual void collect_slot_column_ids(std::set<int>& column_ids) const {
        for (auto child : _children) {
            child->collect_slot_column_ids(column_ids);
        }
    }

#ifdef BE_TEST
    void set_node_type(TExprNodeType::type node_type) { _node_type = node_type; }
#endif
    virtual Status evaluate_ann_range_search(
            const segment_v2::AnnRangeSearchRuntime& runtime,
            const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& cid_to_index_iterators,
            const std::vector<ColumnId>& idx_to_cid,
            const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
            size_t rows_of_segment, roaring::Roaring& row_bitmap,
            segment_v2::AnnIndexStats& ann_index_stats, bool enable_result_cache,
            AnnRangeSearchEvaluationResult& result);

    // Prepare the runtime for ANN range search.
    // AnnRangeSearchRuntime is used to store the runtime information of ann range search.
    // suitable_for_ann_index is used to indicate whether the current expr can be used for ANN range search.
    // If suitable_for_ann_index is false, the we will do exhausted search.
    virtual void prepare_ann_range_search(const doris::VectorSearchUserParams& params,
                                          segment_v2::AnnRangeSearchRuntime& range_search_runtime,
                                          bool& suitable_for_ann_index);

    virtual uint64_t get_digest(uint64_t seed) const;

protected:
    TExprNode clone_texpr_node() const;

    /// Simple debug string that provides no expr subclass-specific information
    std::string debug_string(const std::string& expr_name) const {
        std::stringstream out;
        out << expr_name << "(" << VExpr::debug_string() << ")";
        return out.str();
    }

    // used in expr name
    std::string get_child_names() {
        std::string res;
        for (auto child : _children) {
            if (!res.empty()) {
                res += ", ";
            }
            res += child->expr_name();
        }
        return res;
    }

    // only for errmsg now
    std::string get_child_type_names() {
        std::string res;
        for (auto child : _children) {
            if (!res.empty()) {
                res += ", ";
            }
            res += child->expr_name() + ": " + child->data_type()->get_name();
        }
        return res;
    }

    bool is_const_and_have_executed() const {
        return (is_constant() && (_constant_col != nullptr));
    }

    ColumnPtr get_result_from_const(size_t count) const;

    Status check_constant(const Block& block, ColumnNumbers arguments) const;

    /// Helper function that calls ctx->register(), sets fn_context_index_, and returns the
    /// registered FunctionContext
    void register_function_context(RuntimeState* state, VExprContext* context);

    /// Helper function to initialize function context, called in `open` phase of VExpr:
    /// 1. Set constant columns result of function arguments.
    /// 2. Call function's prepare() to initialize function state, fragment-local or
    /// thread-local according the input `FunctionStateScope` argument.
    Status init_function_context(RuntimeState* state, VExprContext* context,
                                 FunctionContext::FunctionStateScope scope,
                                 const FunctionBasePtr& function) const;

    /// Helper function to close function context, fragment-local or thread-local according
    /// the input `FunctionStateScope` argument. Called in `close` phase of VExpr.
    void close_function_context(VExprContext* context, FunctionContext::FunctionStateScope scope,
                                const FunctionBasePtr& function) const;

    TExprNodeType::type _node_type;
    // Used to check what opcode
    TExprOpcode::type _opcode;
    DataTypePtr _data_type;
    VExprSPtrs _children; // in few hundreds
    TFunction _fn;

    // Planner (FE) verdict on whether this node, as a filter conjunct root, is safe to
    // evaluate on a column dictionary. std::nullopt when the FE did not stamp it (older FE
    // or non-conjunct node); can_push_down_to_dict_filter then falls back to a BE-side
    // conservative check. See TExprNode.can_dict_filter.
    std::optional<bool> _can_dict_filter_from_planner;

    /// Index to pass to ExprContext::fn_context() to retrieve this expr's FunctionContext.
    /// Set in RegisterFunctionContext(). -1 if this expr does not need a FunctionContext and
    /// doesn't call RegisterFunctionContext().
    int _fn_context_index = -1;

    // If this expr is constant, this will store and cache the value generated by
    // get_const_col()
    std::shared_ptr<ColumnPtrWrapper> _constant_col;
    bool _prepared = false; // for base class VExpr
    // for concrete classes
    bool _prepare_finished = false;
    bool _open_finished = false;

    // ensuring uniqueness during index traversal
    uint32_t _index_unique_id = 0;
    bool _enable_inverted_index_query = true;
};

// NOLINTBEGIN(readability-function-size)
template <PrimitiveType T>
Status create_texpr_literal_node(const void* data, TExprNode* node, int precision = 0,
                                 int scale = 0) {
    if constexpr (T == TYPE_BOOLEAN) {
        const auto* origin_value = reinterpret_cast<const bool*>(data);
        TBoolLiteral boolLiteral;
        (*node).__set_node_type(TExprNodeType::BOOL_LITERAL);
        boolLiteral.__set_value(*origin_value);
        (*node).__set_bool_literal(boolLiteral);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_BOOLEAN));
    } else if constexpr (T == TYPE_TINYINT) {
        const auto* origin_value = reinterpret_cast<const int8_t*>(data);
        (*node).__set_node_type(TExprNodeType::INT_LITERAL);
        TIntLiteral intLiteral;
        intLiteral.__set_value(*origin_value);
        (*node).__set_int_literal(intLiteral);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_TINYINT));
    } else if constexpr (T == TYPE_SMALLINT) {
        const auto* origin_value = reinterpret_cast<const int16_t*>(data);
        (*node).__set_node_type(TExprNodeType::INT_LITERAL);
        TIntLiteral intLiteral;
        intLiteral.__set_value(*origin_value);
        (*node).__set_int_literal(intLiteral);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_SMALLINT));
    } else if constexpr (T == TYPE_INT) {
        const auto* origin_value = reinterpret_cast<const int32_t*>(data);
        (*node).__set_node_type(TExprNodeType::INT_LITERAL);
        TIntLiteral intLiteral;
        intLiteral.__set_value(*origin_value);
        (*node).__set_int_literal(intLiteral);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_INT));
    } else if constexpr (T == TYPE_BIGINT) {
        const auto* origin_value = reinterpret_cast<const int64_t*>(data);
        (*node).__set_node_type(TExprNodeType::INT_LITERAL);
        TIntLiteral intLiteral;
        intLiteral.__set_value(*origin_value);
        (*node).__set_int_literal(intLiteral);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_BIGINT));
    } else if constexpr (T == TYPE_LARGEINT) {
        // data may not be 16-byte aligned; use unaligned_load to avoid UB.
        auto origin_value = unaligned_load<int128_t>(data);
        (*node).__set_node_type(TExprNodeType::LARGE_INT_LITERAL);
        TLargeIntLiteral large_int_literal;
        large_int_literal.__set_value(LargeIntValue::to_string(origin_value));
        (*node).__set_large_int_literal(large_int_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_LARGEINT));
    } else if constexpr ((T == TYPE_DATE) || (T == TYPE_DATETIME)) {
        const auto* origin_value = reinterpret_cast<const VecDateTimeValue*>(data);
        TDateLiteral date_literal;
        char convert_buffer[30];
        origin_value->to_string(convert_buffer);
        date_literal.__set_value(convert_buffer);
        (*node).__set_date_literal(date_literal);
        (*node).__set_node_type(TExprNodeType::DATE_LITERAL);
        if (origin_value->type() == TimeType::TIME_DATE) {
            (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATE));
        } else if (origin_value->type() == TimeType::TIME_DATETIME) {
            (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATETIME));
        }
    } else if constexpr (T == TYPE_DATEV2) {
        const auto* origin_value = reinterpret_cast<const DateV2Value<DateV2ValueType>*>(data);
        TDateLiteral date_literal;
        char convert_buffer[30];
        origin_value->to_string(convert_buffer);
        date_literal.__set_value(convert_buffer);
        (*node).__set_date_literal(date_literal);
        (*node).__set_node_type(TExprNodeType::DATE_LITERAL);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATEV2));
    } else if constexpr (T == TYPE_DATETIMEV2) {
        const auto* origin_value = reinterpret_cast<const DateV2Value<DateTimeV2ValueType>*>(data);
        TDateLiteral date_literal;
        char convert_buffer[30];
        origin_value->to_string(convert_buffer, scale);
        date_literal.__set_value(convert_buffer);
        (*node).__set_date_literal(date_literal);
        (*node).__set_node_type(TExprNodeType::DATE_LITERAL);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DATETIMEV2, precision, scale));
    } else if constexpr (T == TYPE_TIMESTAMPTZ) {
        const auto* origin_value = reinterpret_cast<const TimestampTzValue*>(data);
        TDateLiteral date_literal;
        auto tz = cctz::utc_time_zone();
        auto tz_str = origin_value->to_string(tz, scale);
        date_literal.__set_value(tz_str);
        (*node).__set_date_literal(date_literal);
        (*node).__set_node_type(TExprNodeType::DATE_LITERAL);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_TIMESTAMPTZ, precision, scale));
    } else if constexpr (T == TYPE_DECIMALV2) {
        // data may not be 16-byte aligned (DecimalV2Value stores int128_t);
        // use unaligned_load to avoid UB.
        auto origin_value = unaligned_load<DecimalV2Value>(data);
        (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL);
        TDecimalLiteral decimal_literal;
        decimal_literal.__set_value(origin_value.to_string());
        (*node).__set_decimal_literal(decimal_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMALV2, precision, scale));
    } else if constexpr (T == TYPE_DECIMAL32) {
        const auto* origin_value = reinterpret_cast<const Decimal<int32_t>*>(data);
        (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL);
        TDecimalLiteral decimal_literal;
        decimal_literal.__set_value(origin_value->to_string(precision, scale));
        (*node).__set_decimal_literal(decimal_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL32, precision, scale));
    } else if constexpr (T == TYPE_DECIMAL64) {
        const auto* origin_value = reinterpret_cast<const Decimal<int64_t>*>(data);
        (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL);
        TDecimalLiteral decimal_literal;
        decimal_literal.__set_value(origin_value->to_string(precision, scale));
        (*node).__set_decimal_literal(decimal_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL64, precision, scale));
    } else if constexpr (T == TYPE_DECIMAL128I) {
        // data may not be 16-byte aligned; use unaligned_load to avoid UB.
        auto origin_value = unaligned_load<Decimal<int128_t>>(data);
        (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL);
        TDecimalLiteral decimal_literal;
        // e.g. For a decimal(26,6) column, the initial value of the _min of the MinMax RF
        // on the RF producer side is an int128 value with 38 digits of 9, and this is the
        // final min value of the MinMax RF if the fragment instance has no data.
        // Need to truncate the value to the right precision and scale here, to avoid
        // error when casting string back to decimal later.
        // TODO: this is a temporary solution, the best solution is to produce the
        // right min max value at the producer side.
        decimal_literal.__set_value(origin_value.to_string(precision, scale));
        (*node).__set_decimal_literal(decimal_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL128I, precision, scale));
    } else if constexpr (T == TYPE_DECIMAL256) {
        const auto* origin_value = reinterpret_cast<const Decimal<wide::Int256>*>(data);
        (*node).__set_node_type(TExprNodeType::DECIMAL_LITERAL);
        TDecimalLiteral decimal_literal;
        decimal_literal.__set_value(origin_value->to_string(precision, scale));
        (*node).__set_decimal_literal(decimal_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DECIMAL256, precision, scale));
    } else if constexpr (T == TYPE_FLOAT) {
        const auto* origin_value = reinterpret_cast<const float*>(data);
        (*node).__set_node_type(TExprNodeType::FLOAT_LITERAL);
        TFloatLiteral float_literal;
        float_literal.__set_value(*origin_value);
        (*node).__set_float_literal(float_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_FLOAT));
    } else if constexpr (T == TYPE_DOUBLE) {
        const auto* origin_value = reinterpret_cast<const double*>(data);
        (*node).__set_node_type(TExprNodeType::FLOAT_LITERAL);
        TFloatLiteral float_literal;
        float_literal.__set_value(*origin_value);
        (*node).__set_float_literal(float_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_DOUBLE));
    } else if constexpr ((T == TYPE_STRING) || (T == TYPE_CHAR) || (T == TYPE_VARCHAR)) {
        const auto* origin_value = reinterpret_cast<const std::string*>(data);
        (*node).__set_node_type(TExprNodeType::STRING_LITERAL);
        TStringLiteral string_literal;
        string_literal.__set_value(*origin_value);
        (*node).__set_string_literal(string_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_STRING));
    } else if constexpr (T == TYPE_IPV4) {
        const auto* origin_value = reinterpret_cast<const IPv4*>(data);
        (*node).__set_node_type(TExprNodeType::IPV4_LITERAL);
        TIPv4Literal literal;
        literal.__set_value(*origin_value);
        (*node).__set_ipv4_literal(literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_IPV4));
    } else if constexpr (T == TYPE_IPV6) {
        const auto* origin_value = reinterpret_cast<const IPv6*>(data);
        (*node).__set_node_type(TExprNodeType::IPV6_LITERAL);
        TIPv6Literal literal;
        literal.__set_value(CastToString::from_ip(*origin_value));
        (*node).__set_ipv6_literal(literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_IPV6));
    } else if constexpr (T == TYPE_TIMEV2) {
        // the code use for runtime filter but we dont support timev2 as predicate now
        // so this part not used
        const auto* origin_value = reinterpret_cast<const double*>(data);
        TTimeV2Literal timev2_literal;
        timev2_literal.__set_value(*origin_value);
        (*node).__set_timev2_literal(timev2_literal);
        (*node).__set_node_type(TExprNodeType::TIMEV2_LITERAL);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_TIMEV2, precision, scale));
    } else if constexpr (T == TYPE_VARBINARY) {
        const auto* origin_value = reinterpret_cast<const StringView*>(data);
        (*node).__set_node_type(TExprNodeType::VARBINARY_LITERAL);
        TVarBinaryLiteral varbinary_literal;
        varbinary_literal.__set_value(std::string(origin_value->data(), origin_value->size()));
        (*node).__set_varbinary_literal(varbinary_literal);
        (*node).__set_type(create_type_desc(PrimitiveType::TYPE_VARBINARY));
    } else {
        return Status::InvalidArgument("Invalid argument type!");
    }
    return Status::OK();
}
// NOLINTEND(readability-function-size)

TExprNode create_texpr_node_from(const void* data, const PrimitiveType& type, int precision = 0,
                                 int scale = 0);

TExprNode create_texpr_node_from(const Field& field, const PrimitiveType& type, int precision,
                                 int scale);

} // namespace doris

Coverage Report

Created: 2026-07-29 00:04