be/src/exprs/vdirect_in_predicate.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 <utility>
#include <vector>

#include "common/logging.h"
#include "common/status.h"
#include "core/field.h"
#include "core/types.h"
#include "exprs/expr_zonemap_filter.h"
#include "exprs/hybrid_set.h"
#include "exprs/vexpr.h"
#include "exprs/vin_predicate.h"
#include "exprs/vliteral.h"
#include "exprs/vslot_ref.h"

namespace doris {

class VDirectInPredicate final : public VExpr {
    ENABLE_FACTORY_CREATOR(VDirectInPredicate);

public:
    // `hybrid_set_values_match_child_type` tells whether values in `filter` can be interpreted with
    // the child expression type. Parquet/ORC dictionary-filter rewrites evaluate the original
    // logical predicate against dictionary entries and then rewrite it to matched physical
    // dictionary codes, for example `col IN ('a', 'b')` becomes `dict_code IN (0, 1)`. In that
    // shape the HybridSet stores TYPE_INT dictionary codes while the child slot still has the
    // original logical type such as STRING. Callers must pass false to disable zonemap
    // materialization and slot-IN rewrite that would otherwise rebuild child-typed literals from
    // dictionary codes.
    VDirectInPredicate(const TExprNode& node, const std::shared_ptr<HybridSetBase>& filter,
                       bool hybrid_set_values_match_child_type = true)
            : VExpr(node),
              _filter(filter),
              _hybrid_set_values_match_child_type(hybrid_set_values_match_child_type),
              _expr_name("direct_in_predicate") {}
    ~VDirectInPredicate() override = default;

#ifdef BE_TEST
    VDirectInPredicate() = default;
#endif

    Status prepare(RuntimeState* state, const RowDescriptor& row_desc,
                   VExprContext* context) override {
        RETURN_IF_ERROR_OR_PREPARED(VExpr::prepare(state, row_desc, context));
        RETURN_IF_ERROR(_materialize_for_zonemap_filter());
        _prepare_finished = true;
        return Status::OK();
    }

    Status open(RuntimeState* state, VExprContext* context,
                FunctionContext::FunctionStateScope scope) override {
        DCHECK(_prepare_finished);
        RETURN_IF_ERROR(VExpr::open(state, context, scope));
        _open_finished = true;
        return Status::OK();
    }

    Status execute_column_impl(VExprContext* context, const Block* block, const Selector* selector,
                               size_t count, ColumnPtr& result_column) const override {
        return _do_execute(context, block, nullptr, selector, count, result_column, nullptr);
    }

    Status execute_runtime_filter(VExprContext* context, const Block* block,
                                  const uint8_t* __restrict filter, size_t count,
                                  ColumnPtr& result_column, ColumnPtr* arg_column) const override {
        return _do_execute(context, block, filter, nullptr, count, result_column, arg_column);
    }

    const std::string& expr_name() const override { return _expr_name; }

    std::shared_ptr<HybridSetBase> get_set_func() const override { return _filter; }

    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override {
        return expr_zonemap::eval_in_zonemap(ctx, get_child(0), false, _seg_filter_values,
                                             _seg_filter_min, _seg_filter_max);
    }

    bool can_evaluate_zonemap_filter() const override {
        return _zonemap_materialized &&
               std::dynamic_pointer_cast<VSlotRef>(get_child(0)) != nullptr;
    }

    ZoneMapFilterResult evaluate_dictionary_filter(
            const DictionaryEvalContext& ctx) const override {
        return expr_zonemap::eval_in_dictionary(ctx, get_child(0), false, _seg_filter_values);
    }

    bool can_evaluate_dictionary_filter() const override {
        return _zonemap_materialized &&
               std::dynamic_pointer_cast<VSlotRef>(get_child(0)) != nullptr;
    }

    bool can_execute_on_raw_fixed_values(const DataTypePtr& data_type,
                                         int column_id) const override {
        if (!_hybrid_set_values_match_child_type || data_type == nullptr || _filter == nullptr ||
            get_num_children() != 1) {
            return false;
        }
        const auto slot = std::dynamic_pointer_cast<VSlotRef>(get_child(0));
        if (slot == nullptr || slot->column_id() != column_id) {
            return false;
        }
        const auto raw_type = remove_nullable(data_type);
        if (!remove_nullable(slot->data_type())->equals(*raw_type)) {
            return false;
        }
        return _raw_fixed_value_size(raw_type->get_primitive_type()) != 0;
    }

    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 override {
        if (!can_execute_on_raw_fixed_values(data_type, column_id)) {
            return Status::NotSupported(
                    "Direct IN predicate cannot evaluate raw fixed-width values");
        }
        DORIS_CHECK(values != nullptr || num_values == 0);
        DORIS_CHECK(matches != nullptr || num_values == 0);
        const size_t expected_width =
                _raw_fixed_value_size(remove_nullable(data_type)->get_primitive_type());
        if (value_width != expected_width) {
            return Status::Corruption("Raw direct IN width {} does not match expected {}",
                                      value_width, expected_width);
        }
        // Dispatch once per decoder batch so large runtime-filter sets retain the typed HybridSet
        // loop instead of paying a virtual lookup for every physical value.
        _filter->find_batch_raw_fixed(values, num_values, value_width, matches);
        return Status::OK();
    }

    bool can_execute_on_raw_binary_values(const DataTypePtr& data_type,
                                          int column_id) const override {
        if (!_hybrid_set_values_match_child_type || data_type == nullptr || _filter == nullptr ||
            get_num_children() != 1) {
            return false;
        }
        const auto slot = std::dynamic_pointer_cast<VSlotRef>(get_child(0));
        if (slot == nullptr || slot->column_id() != column_id || slot->data_type() == nullptr) {
            return false;
        }
        return is_string_type(remove_nullable(data_type)->get_primitive_type()) &&
               is_string_type(remove_nullable(slot->data_type())->get_primitive_type());
    }

    Status execute_on_raw_binary_values(const StringRef* values, size_t num_values,
                                        const DataTypePtr& data_type, int column_id,
                                        uint8_t* matches) const override {
        if (!can_execute_on_raw_binary_values(data_type, column_id)) {
            return Status::NotSupported("Direct IN predicate cannot evaluate raw binary values");
        }
        DORIS_CHECK(values != nullptr || num_values == 0);
        DORIS_CHECK(matches != nullptr || num_values == 0);
        // Probe immutable decoder slices directly; constructing ColumnString first would copy
        // every rejected payload and defeat predicate-only late materialization.
        _filter->find_batch_raw_binary(values, num_values, matches);
        return Status::OK();
    }

    Status clone_node(VExprSPtr* cloned_expr) const override {
        DORIS_CHECK(cloned_expr != nullptr);
        *cloned_expr = VDirectInPredicate::create_shared(clone_texpr_node(), _filter,
                                                         _hybrid_set_values_match_child_type);
        return Status::OK();
    }

    bool get_slot_in_expr(VExprSPtr& new_root) const {
        if (!_hybrid_set_values_match_child_type) {
            return false;
        }
        if (!get_child(0)->is_slot_ref()) {
            return false;
        }

        auto* slot_ref = assert_cast<VSlotRef*>(get_child(0).get());
        auto slot_data_type = remove_nullable(slot_ref->data_type());
        {
            TTypeDesc type_desc = create_type_desc(PrimitiveType::TYPE_BOOLEAN);
            TExprNode node;
            node.__set_type(type_desc);
            node.__set_node_type(TExprNodeType::IN_PRED);
            node.in_predicate.__set_is_not_in(false);
            node.__set_opcode(TExprOpcode::FILTER_IN);
            // VdirectInPredicate assume is_nullable = false.
            node.__set_is_nullable(false);
            new_root = VInPredicate::create_shared(node);
        }
        {
            // add slot
            new_root->add_child(children().at(0));
        }
        {
            auto iter = get_set_func()->begin();
            while (iter->has_next()) {
                DCHECK(iter->get_value() != nullptr);
                const void* value = iter->get_value();

                TExprNode node = expr_zonemap::create_texpr_node_from_hybrid_set_value(
                        value, slot_data_type->get_primitive_type(),
                        slot_data_type->get_precision(), slot_data_type->get_scale());
                new_root->add_child(VLiteral::create_shared(node));
                iter->next();
            }
        }
        return true;
    }

    uint64_t get_digest(uint64_t seed) const override {
        seed = _children[0]->get_digest(seed);
        if (seed) {
            return _filter->get_digest(seed);
        }
        return seed;
    }

private:
    static size_t _raw_fixed_value_size(PrimitiveType primitive_type) {
        switch (primitive_type) {
#define RETURN_RAW_FIXED_SIZE(TYPE) \
    case TYPE:                      \
        return sizeof(typename PrimitiveTypeTraits<TYPE>::CppType)
            RETURN_RAW_FIXED_SIZE(TYPE_BOOLEAN);
            RETURN_RAW_FIXED_SIZE(TYPE_TINYINT);
            RETURN_RAW_FIXED_SIZE(TYPE_SMALLINT);
            RETURN_RAW_FIXED_SIZE(TYPE_INT);
            RETURN_RAW_FIXED_SIZE(TYPE_BIGINT);
            RETURN_RAW_FIXED_SIZE(TYPE_LARGEINT);
            RETURN_RAW_FIXED_SIZE(TYPE_FLOAT);
            RETURN_RAW_FIXED_SIZE(TYPE_DOUBLE);
            RETURN_RAW_FIXED_SIZE(TYPE_DATE);
            RETURN_RAW_FIXED_SIZE(TYPE_DATETIME);
            RETURN_RAW_FIXED_SIZE(TYPE_DATEV2);
            RETURN_RAW_FIXED_SIZE(TYPE_DATETIMEV2);
            RETURN_RAW_FIXED_SIZE(TYPE_TIMESTAMPTZ);
            RETURN_RAW_FIXED_SIZE(TYPE_TIMEV2);
            RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL32);
            RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL64);
            RETURN_RAW_FIXED_SIZE(TYPE_DECIMALV2);
            RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL128I);
            RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL256);
            RETURN_RAW_FIXED_SIZE(TYPE_IPV4);
            RETURN_RAW_FIXED_SIZE(TYPE_IPV6);
#undef RETURN_RAW_FIXED_SIZE
        default:
            return 0;
        }
    }

    Status _do_execute(VExprContext* context, const Block* block, const uint8_t* __restrict filter,
                       const Selector* selector, size_t count, ColumnPtr& result_column,
                       ColumnPtr* arg_column) const {
        DCHECK(_open_finished || block == nullptr);
        DCHECK(!(filter != nullptr && selector != nullptr))
                << "filter and selector can not be both set";
        ColumnPtr argument_column;
        RETURN_IF_ERROR(
                _children[0]->execute_column(context, block, selector, count, argument_column));
        argument_column = argument_column->convert_to_full_column_if_const();

        if (arg_column != nullptr) {
            *arg_column = argument_column;
        }

        size_t sz = argument_column->size();
        auto res_data_column = ColumnUInt8::create(sz);
        res_data_column->resize(sz);

        if (const auto* nullable = check_and_get_column<ColumnNullable>(argument_column.get())) {
            auto column_nested = nullable->get_nested_column_ptr();
            const auto& null_map = nullable->get_null_map_data();
            _filter->find_batch_nullable(*column_nested, sz, null_map, res_data_column->get_data(),
                                         filter);
        } else {
            _filter->find_batch(*argument_column, sz, res_data_column->get_data(), filter);
        }

        DCHECK(!_data_type->is_nullable());
        result_column = std::move(res_data_column);
        return Status::OK();
    }

    Status _materialize_for_zonemap_filter() {
        if (!_hybrid_set_values_match_child_type) {
            _zonemap_materialized = false;
            return Status::OK();
        }
        DORIS_CHECK(_filter != nullptr);
        auto& filter = *_filter;
        const auto& data_type = remove_nullable(get_child(0)->data_type());
        expr_zonemap::InZonemapMaterializedSet materialized;
        RETURN_IF_ERROR(expr_zonemap::materialize_hybrid_set_for_zonemap_filter(filter, data_type,
                                                                                &materialized));
        _seg_filter_values = std::move(materialized.values);
        _seg_filter_min = std::move(materialized.min_value);
        _seg_filter_max = std::move(materialized.max_value);
        _zonemap_materialized = true;
        return Status::OK();
    }

    std::shared_ptr<HybridSetBase> _filter;
    // Dictionary-filter rewrites may store physical dictionary codes in the HybridSet while the
    // child slot keeps the original logical type. Such values must not be materialized as child-type
    // literals for zonemap pruning or slot-IN rewrite.
    bool _hybrid_set_values_match_child_type = true;
    std::string _expr_name;
    bool _zonemap_materialized = false;
    std::vector<Field> _seg_filter_values;
    Field _seg_filter_min;
    Field _seg_filter_max;
};

} // namespace doris

Coverage Report

Created: 2026-07-30 15:06

Line	Count	Source
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 <utility>
21		#include <vector>
22
23		#include "common/logging.h"
24		#include "common/status.h"
25		#include "core/field.h"
26		#include "core/types.h"
27		#include "exprs/expr_zonemap_filter.h"
28		#include "exprs/hybrid_set.h"
29		#include "exprs/vexpr.h"
30		#include "exprs/vin_predicate.h"
31		#include "exprs/vliteral.h"
32		#include "exprs/vslot_ref.h"
33
34		namespace doris {
35
36		class VDirectInPredicate final : public VExpr {
37		ENABLE_FACTORY_CREATOR(VDirectInPredicate);
38
39		public:
40		// `hybrid_set_values_match_child_type` tells whether values in `filter` can be interpreted with
41		// the child expression type. Parquet/ORC dictionary-filter rewrites evaluate the original
42		// logical predicate against dictionary entries and then rewrite it to matched physical
43		// dictionary codes, for example `col IN ('a', 'b')` becomes `dict_code IN (0, 1)`. In that
44		// shape the HybridSet stores TYPE_INT dictionary codes while the child slot still has the
45		// original logical type such as STRING. Callers must pass false to disable zonemap
46		// materialization and slot-IN rewrite that would otherwise rebuild child-typed literals from
47		// dictionary codes.
48		VDirectInPredicate(const TExprNode& node, const std::shared_ptr<HybridSetBase>& filter,
49		bool hybrid_set_values_match_child_type = true)
50	101	: VExpr(node),
51	101	_filter(filter),
52	101	_hybrid_set_values_match_child_type(hybrid_set_values_match_child_type),
53	101	_expr_name("direct_in_predicate") {}
54	105	~VDirectInPredicate() override = default;
55
56		#ifdef BE_TEST
57	4	VDirectInPredicate() = default;
58		#endif
59
60		Status prepare(RuntimeState* state, const RowDescriptor& row_desc,
61	15	VExprContext* context) override {
62	15	RETURN_IF_ERROR_OR_PREPARED(VExpr::prepare(state, row_desc, context));
63	15	RETURN_IF_ERROR(_materialize_for_zonemap_filter());
64	15	_prepare_finished = true;
65	15	return Status::OK();
66	15	}
67
68		Status open(RuntimeState* state, VExprContext* context,
69	14	FunctionContext::FunctionStateScope scope) override {
70	14	DCHECK(_prepare_finished);
71	14	RETURN_IF_ERROR(VExpr::open(state, context, scope));
72	14	_open_finished = true;
73	14	return Status::OK();
74	14	}
75
76		Status execute_column_impl(VExprContext* context, const Block* block, const Selector* selector,
77	11	size_t count, ColumnPtr& result_column) const override {
78	11	return _do_execute(context, block, nullptr, selector, count, result_column, nullptr);
79	11	}
80
81		Status execute_runtime_filter(VExprContext* context, const Block* block,
82		const uint8_t* __restrict filter, size_t count,
83	6	ColumnPtr& result_column, ColumnPtr* arg_column) const override {
84	6	return _do_execute(context, block, filter, nullptr, count, result_column, arg_column);
85	6	}
86
87	14	const std::string& expr_name() const override { return _expr_name; }
88
89	68	std::shared_ptr<HybridSetBase> get_set_func() const override { return _filter; }
90
91	4	ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override {
92	4	return expr_zonemap::eval_in_zonemap(ctx, get_child(0), false, _seg_filter_values,
93	4	_seg_filter_min, _seg_filter_max);
94	4	}
95
96	26	bool can_evaluate_zonemap_filter() const override {
97	26	return _zonemap_materialized &&
98	26	std::dynamic_pointer_cast<VSlotRef>(get_child(0)) != nullptr;
99	26	}
100
101		ZoneMapFilterResult evaluate_dictionary_filter(
102	3	const DictionaryEvalContext& ctx) const override {
103	3	return expr_zonemap::eval_in_dictionary(ctx, get_child(0), false, _seg_filter_values);
104	3	}
105
106	17	bool can_evaluate_dictionary_filter() const override {
107	17	return _zonemap_materialized &&
108	17	std::dynamic_pointer_cast<VSlotRef>(get_child(0)) != nullptr;
109	17	}
110
111		bool can_execute_on_raw_fixed_values(const DataTypePtr& data_type,
112	48	int column_id) const override {
113	48	if (!_hybrid_set_values_match_child_type \|\| data_type == nullptr \|\| _filter == nullptr \|\|
114	48	get_num_children() != 1) {
115	0	return false;
116	0	}
117	48	const auto slot = std::dynamic_pointer_cast<VSlotRef>(get_child(0));
118	48	if (slot == nullptr \|\| slot->column_id() != column_id) {
119	0	return false;
120	0	}
121	48	const auto raw_type = remove_nullable(data_type);
122	48	if (!remove_nullable(slot->data_type())->equals(*raw_type)) {
123	0	return false;
124	0	}
125	48	return _raw_fixed_value_size(raw_type->get_primitive_type()) != 0;
126	48	}
127
128		Status execute_on_raw_fixed_values(const uint8_t* values, size_t num_values, size_t value_width,
129		const DataTypePtr& data_type, int column_id,
130	5	uint8_t* matches) const override {
131	5	if (!can_execute_on_raw_fixed_values(data_type, column_id)) {
132	0	return Status::NotSupported(
133	0	"Direct IN predicate cannot evaluate raw fixed-width values");
134	0	}
135	5	DORIS_CHECK(values != nullptr \|\| num_values == 0);
136	5	DORIS_CHECK(matches != nullptr \|\| num_values == 0);
137	5	const size_t expected_width =
138	5	_raw_fixed_value_size(remove_nullable(data_type)->get_primitive_type());
139	5	if (value_width != expected_width) {
140	0	return Status::Corruption("Raw direct IN width {} does not match expected {}",
141	0	value_width, expected_width);
142	0	}
143		// Dispatch once per decoder batch so large runtime-filter sets retain the typed HybridSet
144		// loop instead of paying a virtual lookup for every physical value.
145	5	_filter->find_batch_raw_fixed(values, num_values, value_width, matches);
146	5	return Status::OK();
147	5	}
148
149		bool can_execute_on_raw_binary_values(const DataTypePtr& data_type,
150	9	int column_id) const override {
151	9	if (!_hybrid_set_values_match_child_type \|\| data_type == nullptr \|\| _filter == nullptr \|\|
152	9	get_num_children() != 1) {
153	0	return false;
154	0	}
155	9	const auto slot = std::dynamic_pointer_cast<VSlotRef>(get_child(0));
156	9	if (slot == nullptr \|\| slot->column_id() != column_id \|\| slot->data_type() == nullptr) {
157	0	return false;
158	0	}
159	9	return is_string_type(remove_nullable(data_type)->get_primitive_type()) &&
160	9	is_string_type(remove_nullable(slot->data_type())->get_primitive_type());
161	9	}
162
163		Status execute_on_raw_binary_values(const StringRef* values, size_t num_values,
164		const DataTypePtr& data_type, int column_id,
165	1	uint8_t* matches) const override {
166	1	if (!can_execute_on_raw_binary_values(data_type, column_id)) {
167	0	return Status::NotSupported("Direct IN predicate cannot evaluate raw binary values");
168	0	}
169	1	DORIS_CHECK(values != nullptr \|\| num_values == 0);
170	1	DORIS_CHECK(matches != nullptr \|\| num_values == 0);
171		// Probe immutable decoder slices directly; constructing ColumnString first would copy
172		// every rejected payload and defeat predicate-only late materialization.
173	1	_filter->find_batch_raw_binary(values, num_values, matches);
174	1	return Status::OK();
175	1	}
176
177	2	Status clone_node(VExprSPtr* cloned_expr) const override {
178	2	DORIS_CHECK(cloned_expr != nullptr);
179	2	*cloned_expr = VDirectInPredicate::create_shared(clone_texpr_node(), _filter,
180	2	_hybrid_set_values_match_child_type);
181	2	return Status::OK();
182	2	}
183
184	9	bool get_slot_in_expr(VExprSPtr& new_root) const {
185	9	if (!_hybrid_set_values_match_child_type) {
186	1	return false;
187	1	}
188	8	if (!get_child(0)->is_slot_ref()) {
189	0	return false;
190	0	}
191
192	8	auto* slot_ref = assert_cast<VSlotRef*>(get_child(0).get());
193	8	auto slot_data_type = remove_nullable(slot_ref->data_type());
194	8	{
195	8	TTypeDesc type_desc = create_type_desc(PrimitiveType::TYPE_BOOLEAN);
196	8	TExprNode node;
197	8	node.__set_type(type_desc);
198	8	node.__set_node_type(TExprNodeType::IN_PRED);
199	8	node.in_predicate.__set_is_not_in(false);
200	8	node.__set_opcode(TExprOpcode::FILTER_IN);
201		// VdirectInPredicate assume is_nullable = false.
202	8	node.__set_is_nullable(false);
203	8	new_root = VInPredicate::create_shared(node);
204	8	}
205	8	{
206		// add slot
207	8	new_root->add_child(children().at(0));
208	8	}
209	8	{
210	8	auto iter = get_set_func()->begin();
211	3.09k	while (iter->has_next()) {
212	3.08k	DCHECK(iter->get_value() != nullptr);
213	3.08k	const void* value = iter->get_value();
214
215	3.08k	TExprNode node = expr_zonemap::create_texpr_node_from_hybrid_set_value(
216	3.08k	value, slot_data_type->get_primitive_type(),
217	3.08k	slot_data_type->get_precision(), slot_data_type->get_scale());
218	3.08k	new_root->add_child(VLiteral::create_shared(node));
219	3.08k	iter->next();
220	3.08k	}
221	8	}
222	8	return true;
223	8	}
224
225	4	uint64_t get_digest(uint64_t seed) const override {
226	4	seed = _children[0]->get_digest(seed);
227	4	if (seed) {
228	4	return _filter->get_digest(seed);
229	4	}
230	0	return seed;
231	4	}
232
233		private:
234	53	static size_t _raw_fixed_value_size(PrimitiveType primitive_type) {
235	53	switch (primitive_type) {
236	0	#define RETURN_RAW_FIXED_SIZE(TYPE) \
237	50	case TYPE: \
238	50	return sizeof(typename PrimitiveTypeTraits<TYPE>::CppType)
239	1	RETURN_RAW_FIXED_SIZE(TYPE_BOOLEAN);
240	8	RETURN_RAW_FIXED_SIZE(TYPE_TINYINT);
241	1	RETURN_RAW_FIXED_SIZE(TYPE_SMALLINT);
242	16	RETURN_RAW_FIXED_SIZE(TYPE_INT);
243	1	RETURN_RAW_FIXED_SIZE(TYPE_BIGINT);
244	1	RETURN_RAW_FIXED_SIZE(TYPE_LARGEINT);
245	1	RETURN_RAW_FIXED_SIZE(TYPE_FLOAT);
246	1	RETURN_RAW_FIXED_SIZE(TYPE_DOUBLE);
247	1	RETURN_RAW_FIXED_SIZE(TYPE_DATE);
248	1	RETURN_RAW_FIXED_SIZE(TYPE_DATETIME);
249	1	RETURN_RAW_FIXED_SIZE(TYPE_DATEV2);
250	1	RETURN_RAW_FIXED_SIZE(TYPE_DATETIMEV2);
251	1	RETURN_RAW_FIXED_SIZE(TYPE_TIMESTAMPTZ);
252	1	RETURN_RAW_FIXED_SIZE(TYPE_TIMEV2);
253	1	RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL32);
254	8	RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL64);
255	1	RETURN_RAW_FIXED_SIZE(TYPE_DECIMALV2);
256	1	RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL128I);
257	1	RETURN_RAW_FIXED_SIZE(TYPE_DECIMAL256);
258	1	RETURN_RAW_FIXED_SIZE(TYPE_IPV4);
259	1	RETURN_RAW_FIXED_SIZE(TYPE_IPV6);
260	0	#undef RETURN_RAW_FIXED_SIZE
261	3	default:
262	3	return 0;
263	53	}
264	53	}
265
266		Status _do_execute(VExprContext* context, const Block* block, const uint8_t* __restrict filter,
267		const Selector* selector, size_t count, ColumnPtr& result_column,
268	17	ColumnPtr* arg_column) const {
269	17	DCHECK(_open_finished \|\| block == nullptr);
270	17	DCHECK(!(filter != nullptr && selector != nullptr))
271	0	<< "filter and selector can not be both set";
272	17	ColumnPtr argument_column;
273	17	RETURN_IF_ERROR(
274	17	_children[0]->execute_column(context, block, selector, count, argument_column));
275	17	argument_column = argument_column->convert_to_full_column_if_const();
276
277	17	if (arg_column != nullptr) {
278	6	*arg_column = argument_column;
279	6	}
280
281	17	size_t sz = argument_column->size();
282	17	auto res_data_column = ColumnUInt8::create(sz);
283	17	res_data_column->resize(sz);
284
285	17	if (const auto* nullable = check_and_get_column<ColumnNullable>(argument_column.get())) {
286	16	auto column_nested = nullable->get_nested_column_ptr();
287	16	const auto& null_map = nullable->get_null_map_data();
288	16	_filter->find_batch_nullable(*column_nested, sz, null_map, res_data_column->get_data(),
289	16	filter);
290	16	} else {
291	1	_filter->find_batch(*argument_column, sz, res_data_column->get_data(), filter);
292	1	}
293
294	17	DCHECK(!_data_type->is_nullable());
295	17	result_column = std::move(res_data_column);
296	17	return Status::OK();
297	17	}
298
299	19	Status _materialize_for_zonemap_filter() {
300	19	if (!_hybrid_set_values_match_child_type) {
301	1	_zonemap_materialized = false;
302	1	return Status::OK();
303	1	}
304	18	DORIS_CHECK(_filter != nullptr);
305	18	auto& filter = *_filter;
306	18	const auto& data_type = remove_nullable(get_child(0)->data_type());
307	18	expr_zonemap::InZonemapMaterializedSet materialized;
308	18	RETURN_IF_ERROR(expr_zonemap::materialize_hybrid_set_for_zonemap_filter(filter, data_type,
309	18	&materialized));
310	18	_seg_filter_values = std::move(materialized.values);
311	18	_seg_filter_min = std::move(materialized.min_value);
312	18	_seg_filter_max = std::move(materialized.max_value);
313	18	_zonemap_materialized = true;
314	18	return Status::OK();
315	18	}
316
317		std::shared_ptr<HybridSetBase> _filter;
318		// Dictionary-filter rewrites may store physical dictionary codes in the HybridSet while the
319		// child slot keeps the original logical type. Such values must not be materialized as child-type
320		// literals for zonemap pruning or slot-IN rewrite.
321		bool _hybrid_set_values_match_child_type = true;
322		std::string _expr_name;
323		bool _zonemap_materialized = false;
324		std::vector<Field> _seg_filter_values;
325		Field _seg_filter_min;
326		Field _seg_filter_max;
327		};
328
329		} // namespace doris