be/src/exprs/vcompound_pred.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/Opcodes_types.h>

#include <algorithm>
#include <cstdint>

#include "common/status.h"
#include "core/assert_cast.h"
#include "core/column/column.h"
#include "core/column/column_nullable.h"
#include "exprs/vectorized_fn_call.h"
#include "exprs/vexpr_context.h"
#include "exprs/vexpr_fwd.h"
#include "util/simd/bits.h"

namespace doris {
#include "common/compile_check_begin.h"

inline std::string compound_operator_to_string(TExprOpcode::type op) {
    if (op == TExprOpcode::COMPOUND_AND) {
        return "and";
    } else if (op == TExprOpcode::COMPOUND_OR) {
        return "or";
    } else {
        return "not";
    }
}

class VCompoundPred : public VectorizedFnCall {
    ENABLE_FACTORY_CREATOR(VCompoundPred);

public:
    VCompoundPred(const TExprNode& node) : VectorizedFnCall(node) {
        _op = node.opcode;
        _fn.name.function_name = compound_operator_to_string(_op);
        _expr_name = fmt::format("VCompoundPredicate[{}](arguments={},return={})",
                                 _fn.name.function_name, get_child_names(), _data_type->get_name());
    }

#ifdef BE_TEST
    VCompoundPred() = default;
#endif

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

    Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) override {
        segment_v2::InvertedIndexResultBitmap res;
        bool all_pass = true;

        switch (_op) {
        case TExprOpcode::COMPOUND_OR: {
            for (const auto& child : _children) {
                if (Status st = child->evaluate_inverted_index(context, segment_num_rows);
                    !st.ok()) {
                    LOG(ERROR) << "expr:" << child->expr_name()
                               << " evaluate_inverted_index error:" << st.to_string();
                    all_pass = false;
                    continue;
                }
                auto inverted_index_context = context->get_index_context();
                if (inverted_index_context->has_index_result_for_expr(child.get())) {
                    const auto* index_result =
                            inverted_index_context->get_index_result_for_expr(child.get());
                    if (res.is_empty()) {
                        res = *index_result;
                    } else {
                        res |= *index_result;
                    }
                    if (inverted_index_context->get_score_runtime() == nullptr) {
                        if (res.get_data_bitmap()->cardinality() == segment_num_rows) {
                            break; // Early exit if result is full
                        }
                    }
                } else {
                    all_pass = false;
                }
            }
            break;
        }
        case TExprOpcode::COMPOUND_AND: {
            for (const auto& child : _children) {
                if (Status st = child->evaluate_inverted_index(context, segment_num_rows);
                    !st.ok()) {
                    LOG(ERROR) << "expr:" << child->expr_name()
                               << " evaluate_inverted_index error:" << st.to_string();
                    all_pass = false;
                    continue;
                }
                if (context->get_index_context()->has_index_result_for_expr(child.get())) {
                    const auto* index_result =
                            context->get_index_context()->get_index_result_for_expr(child.get());
                    if (res.is_empty()) {
                        res = *index_result;
                    } else {
                        res &= *index_result;
                    }

                    if (res.get_data_bitmap()->isEmpty()) {
                        break; // Early exit if result is empty
                    }
                } else {
                    all_pass = false;
                }
            }
            break;
        }
        case TExprOpcode::COMPOUND_NOT: {
            const auto& child = _children[0];
            Status st = child->evaluate_inverted_index(context, segment_num_rows);
            if (!st.ok()) {
                LOG(ERROR) << "expr:" << child->expr_name()
                           << " evaluate_inverted_index error:" << st.to_string();
                return st;
            }

            if (context->get_index_context()->has_index_result_for_expr(child.get())) {
                const auto* index_result =
                        context->get_index_context()->get_index_result_for_expr(child.get());
                roaring::Roaring full_result;
                full_result.addRange(0, segment_num_rows);
                res = index_result->op_not(&full_result);
            } else {
                all_pass = false;
            }
            break;
        }
        default:
            return Status::NotSupported(
                    "Compound operator must be AND, OR, or NOT to execute with inverted index.");
        }

        if (all_pass && !res.is_empty()) {
            context->get_index_context()->set_index_result_for_expr(this, res);
        }
        return Status::OK();
    }

    Status execute_column(VExprContext* context, const Block* block, Selector* selector,
                          size_t count, ColumnPtr& result_column) const override {
        if (fast_execute(context, selector, count, result_column)) {
            return Status::OK();
        }
        if (get_num_children() == 1 || _has_const_child()) {
            return VectorizedFnCall::execute_column(context, block, selector, count, result_column);
        }

        ColumnPtr lhs_column;
        RETURN_IF_ERROR(_children[0]->execute_column(context, block, selector, count, lhs_column));
        lhs_column = lhs_column->convert_to_full_column_if_const();
        size_t size = lhs_column->size();

        bool lhs_is_nullable = lhs_column->is_nullable();
        auto [lhs_data_column, lhs_null_map] =
                _get_raw_data_and_null_map(lhs_column, lhs_is_nullable);
        size_t filted = simd::count_zero_num((int8_t*)lhs_data_column, size);
        bool lhs_all_true = (filted == 0);
        bool lhs_all_false = (filted == size);

        bool lhs_all_is_not_null = false;
        if (lhs_is_nullable) {
            filted = simd::count_zero_num((int8_t*)lhs_null_map, size);
            lhs_all_is_not_null = (filted == size);
        }

        ColumnPtr rhs_column = nullptr;
        uint8_t* __restrict rhs_data_column = nullptr;
        uint8_t* __restrict rhs_null_map = nullptr;
        bool rhs_is_nullable = false;
        bool rhs_all_true = false;
        bool rhs_all_false = false;
        bool rhs_all_is_not_null = false;
        bool result_is_nullable = _data_type->is_nullable();

        auto get_rhs_colum = [&]() {
            if (!rhs_column) {
                RETURN_IF_ERROR(
                        _children[1]->execute_column(context, block, selector, count, rhs_column));
                rhs_column = rhs_column->convert_to_full_column_if_const();
                rhs_is_nullable = rhs_column->is_nullable();
                auto rhs_nullable_column = _get_raw_data_and_null_map(rhs_column, rhs_is_nullable);
                rhs_data_column = rhs_nullable_column.first;
                rhs_null_map = rhs_nullable_column.second;
                size_t filted = simd::count_zero_num((int8_t*)rhs_data_column, size);
                rhs_all_true = (filted == 0);
                rhs_all_false = (filted == size);
                if (rhs_is_nullable) {
                    filted = simd::count_zero_num((int8_t*)rhs_null_map, size);
                    rhs_all_is_not_null = (filted == size);
                }
            }
            return Status::OK();
        };

        auto return_result_column_id = [&](ColumnPtr& arg_column) {
            result_column = std::move(*arg_column).mutate();
            if (result_is_nullable && !result_column->is_nullable()) {
                result_column = make_nullable(result_column);
            }
        };

        auto create_null_map_column = [&](ColumnPtr& null_map_column,
                                          uint8_t* __restrict null_map_data) {
            if (null_map_data == nullptr) {
                null_map_column = ColumnUInt8::create(size, 0);
                null_map_data = assert_cast<ColumnUInt8*>(null_map_column->assume_mutable().get())
                                        ->get_data()
                                        .data();
            }
            return null_map_data;
        };

        auto vector_vector = [&]<bool is_and_op>() {
            if (lhs_column->use_count() == 1) {
                result_column = lhs_column;
            } else if (rhs_column->use_count() == 1) {
                result_column = rhs_column;
                auto tmp_column = rhs_data_column;
                rhs_data_column = lhs_data_column;
                lhs_data_column = tmp_column;
            } else {
                auto col_res = lhs_column->clone_resized(size);
                lhs_data_column = assert_cast<ColumnUInt8*>(col_res.get())->get_data().data();
                result_column = std::move(col_res);
            }

            do_not_null_pred<is_and_op>(lhs_data_column, rhs_data_column, size);
        };
        auto vector_vector_null = [&]<bool is_and_op>() {
            auto col_res = ColumnUInt8::create(size);
            auto col_nulls = ColumnUInt8::create(size);

            auto* __restrict res_datas =
                    assert_cast<ColumnUInt8*>(col_res.get())->get_data().data();
            auto* __restrict res_nulls =
                    assert_cast<ColumnUInt8*>(col_nulls.get())->get_data().data();
            ColumnPtr temp_null_map = nullptr;
            // maybe both children are nullable / or one of children is nullable
            auto* __restrict lhs_null_map_tmp = create_null_map_column(temp_null_map, lhs_null_map);
            auto* __restrict rhs_null_map_tmp = create_null_map_column(temp_null_map, rhs_null_map);
            auto* __restrict lhs_data_column_tmp = lhs_data_column;
            auto* __restrict rhs_data_column_tmp = rhs_data_column;

            do_null_pred<is_and_op>(lhs_data_column_tmp, lhs_null_map_tmp, rhs_data_column_tmp,
                                    rhs_null_map_tmp, res_datas, res_nulls, size);

            result_column = ColumnNullable::create(std::move(col_res), std::move(col_nulls));
        };

        // false and NULL ----> 0
        // true  and NULL ----> NULL
        if (_op == TExprOpcode::COMPOUND_AND) {
            //1. not null column: all data is false
            //2. nullable column: null map all is not null
            if ((lhs_all_false && !lhs_is_nullable) || (lhs_all_false && lhs_all_is_not_null)) {
                // false and any = false, return lhs
                return_result_column_id(lhs_column);
            } else {
                RETURN_IF_ERROR(get_rhs_colum());

                if ((lhs_all_true && !lhs_is_nullable) ||    //not null column
                    (lhs_all_true && lhs_all_is_not_null)) { //nullable column
                                                             // true and any = any, return rhs

                    return_result_column_id(rhs_column);
                } else if ((rhs_all_false && !rhs_is_nullable) ||
                           (rhs_all_false && rhs_all_is_not_null)) {
                    // any and false = false, return rhs
                    return_result_column_id(rhs_column);
                } else if ((rhs_all_true && !rhs_is_nullable) ||
                           (rhs_all_true && rhs_all_is_not_null)) {
                    // any and true = any, return lhs
                    return_result_column_id(lhs_column);
                } else {
                    if (!result_is_nullable) {
                        vector_vector.template operator()<true>();
                    } else {
                        vector_vector_null.template operator()<true>();
                    }
                }
            }
        } else if (_op == TExprOpcode::COMPOUND_OR) {
            // true  or NULL ----> 1
            // false or NULL ----> NULL
            if ((lhs_all_true && !lhs_is_nullable) || (lhs_all_true && lhs_all_is_not_null)) {
                // true or any = true, return lhs
                return_result_column_id(lhs_column);
            } else {
                RETURN_IF_ERROR(get_rhs_colum());
                if ((lhs_all_false && !lhs_is_nullable) || (lhs_all_false && lhs_all_is_not_null)) {
                    // false or any = any, return rhs
                    return_result_column_id(rhs_column);
                } else if ((rhs_all_true && !rhs_is_nullable) ||
                           (rhs_all_true && rhs_all_is_not_null)) {
                    // any or true = true, return rhs
                    return_result_column_id(rhs_column);
                } else if ((rhs_all_false && !rhs_is_nullable) ||
                           (rhs_all_false && rhs_all_is_not_null)) {
                    // any or false = any, return lhs
                    return_result_column_id(lhs_column);
                } else {
                    if (!result_is_nullable) {
                        vector_vector.template operator()<false>();
                    } else {
                        vector_vector_null.template operator()<false>();
                    }
                }
            }
        } else {
            return Status::InternalError("Compound operator must be AND or OR.");
        }

        DCHECK_EQ(result_column->size(), count);
        return Status::OK();
    }

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

private:
    static inline constexpr uint8_t apply_and_null(UInt8 a, UInt8 l_null, UInt8 b, UInt8 r_null) {
        // (<> && false) is false, (true && NULL) is NULL
        return (l_null & r_null) | (r_null & (l_null ^ a)) | (l_null & (r_null ^ b));
    }
    static inline constexpr uint8_t apply_or_null(UInt8 a, UInt8 l_null, UInt8 b, UInt8 r_null) {
        // (<> || true) is true, (false || NULL) is NULL
        return (l_null & r_null) | (r_null & (r_null ^ a)) | (l_null & (l_null ^ b));
    }

    template <bool is_and>
    void static do_not_null_pred(uint8_t* __restrict lhs, uint8_t* __restrict rhs, size_t size) {
#ifdef NDEBUG
#if defined(__clang__)
#pragma clang loop vectorize(enable)
#elif defined(__GNUC__) && (__GNUC__ >= 5)
#pragma GCC ivdep
#endif
#endif
        for (size_t i = 0; i < size; ++i) {
            if constexpr (is_and) {
                lhs[i] &= rhs[i];
            } else {
                lhs[i] |= rhs[i];
            }
        }
    }

    template <bool is_and>
    void static do_null_pred(uint8_t* __restrict lhs_data, uint8_t* __restrict lhs_null,
                             uint8_t* __restrict rhs_data, uint8_t* __restrict rhs_null,
                             uint8_t* __restrict res_data, uint8_t* __restrict res_null,
                             size_t size) {
#ifdef NDEBUG
#if defined(__clang__)
#pragma clang loop vectorize(enable)
#elif defined(__GNUC__) && (__GNUC__ >= 5)
#pragma GCC ivdep
#endif
#endif
        for (size_t i = 0; i < size; ++i) {
            if constexpr (is_and) {
                res_null[i] = apply_and_null(lhs_data[i], lhs_null[i], rhs_data[i], rhs_null[i]);
                res_data[i] = lhs_data[i] & rhs_data[i];
            } else {
                res_null[i] = apply_or_null(lhs_data[i], lhs_null[i], rhs_data[i], rhs_null[i]);
                res_data[i] = lhs_data[i] | rhs_data[i];
            }
        }
    }

    bool _has_const_child() const {
        return std::ranges::any_of(_children,
                                   [](const VExprSPtr& arg) -> bool { return arg->is_constant(); });
    }

    std::pair<uint8_t*, uint8_t*> _get_raw_data_and_null_map(ColumnPtr column,
                                                             bool has_nullable_column) const {
        if (has_nullable_column) {
            auto* nullable_column = assert_cast<ColumnNullable*>(column->assume_mutable().get());
            auto* data_column =
                    assert_cast<ColumnUInt8*>(nullable_column->get_nested_column_ptr().get())
                            ->get_data()
                            .data();
            auto* null_map =
                    assert_cast<ColumnUInt8*>(nullable_column->get_null_map_column_ptr().get())
                            ->get_data()
                            .data();
            return std::make_pair(data_column, null_map);
        } else {
            auto* data_column =
                    assert_cast<ColumnUInt8*>(column->assume_mutable().get())->get_data().data();
            return std::make_pair(data_column, nullptr);
        }
    }

    TExprOpcode::type _op;
};

#include "common/compile_check_end.h"
} // namespace doris

Coverage Report

Created: 2026-03-16 21:03

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		#include <gen_cpp/Opcodes_types.h>
20
21		#include <algorithm>
22		#include <cstdint>
23
24		#include "common/status.h"
25		#include "core/assert_cast.h"
26		#include "core/column/column.h"
27		#include "core/column/column_nullable.h"
28		#include "exprs/vectorized_fn_call.h"
29		#include "exprs/vexpr_context.h"
30		#include "exprs/vexpr_fwd.h"
31		#include "util/simd/bits.h"
32
33		namespace doris {
34		#include "common/compile_check_begin.h"
35
36	17	inline std::string compound_operator_to_string(TExprOpcode::type op) {
37	17	if (op == TExprOpcode::COMPOUND_AND) {
38	8	return "and";
39	9	} else if (op == TExprOpcode::COMPOUND_OR) {
40	9	return "or";
41	9	} else {
42	0	return "not";
43	0	}
44	17	}
45
46		class VCompoundPred : public VectorizedFnCall {
47		ENABLE_FACTORY_CREATOR(VCompoundPred);
48
49		public:
50	17	VCompoundPred(const TExprNode& node) : VectorizedFnCall(node) {
51	17	_op = node.opcode;
52	17	_fn.name.function_name = compound_operator_to_string(_op);
53	17	_expr_name = fmt::format("VCompoundPredicate[{}](arguments={},return={})",
54	17	_fn.name.function_name, get_child_names(), _data_type->get_name());
55	17	}
56
57		#ifdef BE_TEST
58	2	VCompoundPred() = default;
59		#endif
60
61	18	const std::string& expr_name() const override { return _expr_name; }
62
63	0	Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) override {
64	0	segment_v2::InvertedIndexResultBitmap res;
65	0	bool all_pass = true;
66
67	0	switch (_op) {
68	0	case TExprOpcode::COMPOUND_OR: {
69	0	for (const auto& child : _children) {
70	0	if (Status st = child->evaluate_inverted_index(context, segment_num_rows);
71	0	!st.ok()) {
72	0	LOG(ERROR) << "expr:" << child->expr_name()
73	0	<< " evaluate_inverted_index error:" << st.to_string();
74	0	all_pass = false;
75	0	continue;
76	0	}
77	0	auto inverted_index_context = context->get_index_context();
78	0	if (inverted_index_context->has_index_result_for_expr(child.get())) {
79	0	const auto* index_result =
80	0	inverted_index_context->get_index_result_for_expr(child.get());
81	0	if (res.is_empty()) {
82	0	res = *index_result;
83	0	} else {
84	0	res \|= *index_result;
85	0	}
86	0	if (inverted_index_context->get_score_runtime() == nullptr) {
87	0	if (res.get_data_bitmap()->cardinality() == segment_num_rows) {
88	0	break; // Early exit if result is full
89	0	}
90	0	}
91	0	} else {
92	0	all_pass = false;
93	0	}
94	0	}
95	0	break;
96	0	}
97	0	case TExprOpcode::COMPOUND_AND: {
98	0	for (const auto& child : _children) {
99	0	if (Status st = child->evaluate_inverted_index(context, segment_num_rows);
100	0	!st.ok()) {
101	0	LOG(ERROR) << "expr:" << child->expr_name()
102	0	<< " evaluate_inverted_index error:" << st.to_string();
103	0	all_pass = false;
104	0	continue;
105	0	}
106	0	if (context->get_index_context()->has_index_result_for_expr(child.get())) {
107	0	const auto* index_result =
108	0	context->get_index_context()->get_index_result_for_expr(child.get());
109	0	if (res.is_empty()) {
110	0	res = *index_result;
111	0	} else {
112	0	res &= *index_result;
113	0	}
114
115	0	if (res.get_data_bitmap()->isEmpty()) {
116	0	break; // Early exit if result is empty
117	0	}
118	0	} else {
119	0	all_pass = false;
120	0	}
121	0	}
122	0	break;
123	0	}
124	0	case TExprOpcode::COMPOUND_NOT: {
125	0	const auto& child = _children[0];
126	0	Status st = child->evaluate_inverted_index(context, segment_num_rows);
127	0	if (!st.ok()) {
128	0	LOG(ERROR) << "expr:" << child->expr_name()
129	0	<< " evaluate_inverted_index error:" << st.to_string();
130	0	return st;
131	0	}
132
133	0	if (context->get_index_context()->has_index_result_for_expr(child.get())) {
134	0	const auto* index_result =
135	0	context->get_index_context()->get_index_result_for_expr(child.get());
136	0	roaring::Roaring full_result;
137	0	full_result.addRange(0, segment_num_rows);
138	0	res = index_result->op_not(&full_result);
139	0	} else {
140	0	all_pass = false;
141	0	}
142	0	break;
143	0	}
144	0	default:
145	0	return Status::NotSupported(
146	0	"Compound operator must be AND, OR, or NOT to execute with inverted index.");
147	0	}
148
149	0	if (all_pass && !res.is_empty()) {
150	0	context->get_index_context()->set_index_result_for_expr(this, res);
151	0	}
152	0	return Status::OK();
153	0	}
154
155		Status execute_column(VExprContext* context, const Block* block, Selector* selector,
156	0	size_t count, ColumnPtr& result_column) const override {
157	0	if (fast_execute(context, selector, count, result_column)) {
158	0	return Status::OK();
159	0	}
160	0	if (get_num_children() == 1 \|\| _has_const_child()) {
161	0	return VectorizedFnCall::execute_column(context, block, selector, count, result_column);
162	0	}
163
164	0	ColumnPtr lhs_column;
165	0	RETURN_IF_ERROR(_children[0]->execute_column(context, block, selector, count, lhs_column));
166	0	lhs_column = lhs_column->convert_to_full_column_if_const();
167	0	size_t size = lhs_column->size();
168
169	0	bool lhs_is_nullable = lhs_column->is_nullable();
170	0	auto [lhs_data_column, lhs_null_map] =
171	0	_get_raw_data_and_null_map(lhs_column, lhs_is_nullable);
172	0	size_t filted = simd::count_zero_num((int8_t*)lhs_data_column, size);
173	0	bool lhs_all_true = (filted == 0);
174	0	bool lhs_all_false = (filted == size);
175
176	0	bool lhs_all_is_not_null = false;
177	0	if (lhs_is_nullable) {
178	0	filted = simd::count_zero_num((int8_t*)lhs_null_map, size);
179	0	lhs_all_is_not_null = (filted == size);
180	0	}
181
182	0	ColumnPtr rhs_column = nullptr;
183	0	uint8_t* __restrict rhs_data_column = nullptr;
184	0	uint8_t* __restrict rhs_null_map = nullptr;
185	0	bool rhs_is_nullable = false;
186	0	bool rhs_all_true = false;
187	0	bool rhs_all_false = false;
188	0	bool rhs_all_is_not_null = false;
189	0	bool result_is_nullable = _data_type->is_nullable();
190
191	0	auto get_rhs_colum = [&]() {
192	0	if (!rhs_column) {
193	0	RETURN_IF_ERROR(
194	0	_children[1]->execute_column(context, block, selector, count, rhs_column));
195	0	rhs_column = rhs_column->convert_to_full_column_if_const();
196	0	rhs_is_nullable = rhs_column->is_nullable();
197	0	auto rhs_nullable_column = _get_raw_data_and_null_map(rhs_column, rhs_is_nullable);
198	0	rhs_data_column = rhs_nullable_column.first;
199	0	rhs_null_map = rhs_nullable_column.second;
200	0	size_t filted = simd::count_zero_num((int8_t*)rhs_data_column, size);
201	0	rhs_all_true = (filted == 0);
202	0	rhs_all_false = (filted == size);
203	0	if (rhs_is_nullable) {
204	0	filted = simd::count_zero_num((int8_t*)rhs_null_map, size);
205	0	rhs_all_is_not_null = (filted == size);
206	0	}
207	0	}
208	0	return Status::OK();
209	0	};
210
211	0	auto return_result_column_id = [&](ColumnPtr& arg_column) {
212	0	result_column = std::move(*arg_column).mutate();
213	0	if (result_is_nullable && !result_column->is_nullable()) {
214	0	result_column = make_nullable(result_column);
215	0	}
216	0	};
217
218	0	auto create_null_map_column = [&](ColumnPtr& null_map_column,
219	0	uint8_t* __restrict null_map_data) {
220	0	if (null_map_data == nullptr) {
221	0	null_map_column = ColumnUInt8::create(size, 0);
222	0	null_map_data = assert_cast<ColumnUInt8*>(null_map_column->assume_mutable().get())
223	0	->get_data()
224	0	.data();
225	0	}
226	0	return null_map_data;
227	0	};
228
229	0	auto vector_vector = [&]<bool is_and_op>() {
230	0	if (lhs_column->use_count() == 1) {
231	0	result_column = lhs_column;
232	0	} else if (rhs_column->use_count() == 1) {
233	0	result_column = rhs_column;
234	0	auto tmp_column = rhs_data_column;
235	0	rhs_data_column = lhs_data_column;
236	0	lhs_data_column = tmp_column;
237	0	} else {
238	0	auto col_res = lhs_column->clone_resized(size);
239	0	lhs_data_column = assert_cast<ColumnUInt8*>(col_res.get())->get_data().data();
240	0	result_column = std::move(col_res);
241	0	}
242
243	0	do_not_null_pred<is_and_op>(lhs_data_column, rhs_data_column, size);
244	0	}; Unexecuted instantiation: _ZZNK5doris13VCompoundPred14execute_columnEPNS_12VExprContextEPKNS_5BlockEPNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEmRNS_3COWINS_7IColumnEE13immutable_ptrISD_EEENKUlTnbvE_clILb1EEEDav Unexecuted instantiation: _ZZNK5doris13VCompoundPred14execute_columnEPNS_12VExprContextEPKNS_5BlockEPNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEmRNS_3COWINS_7IColumnEE13immutable_ptrISD_EEENKUlTnbvE_clILb0EEEDav
245	0	auto vector_vector_null = [&]<bool is_and_op>() {
246	0	auto col_res = ColumnUInt8::create(size);
247	0	auto col_nulls = ColumnUInt8::create(size);
248
249	0	auto* __restrict res_datas =
250	0	assert_cast<ColumnUInt8*>(col_res.get())->get_data().data();
251	0	auto* __restrict res_nulls =
252	0	assert_cast<ColumnUInt8*>(col_nulls.get())->get_data().data();
253	0	ColumnPtr temp_null_map = nullptr;
254		// maybe both children are nullable / or one of children is nullable
255	0	auto* __restrict lhs_null_map_tmp = create_null_map_column(temp_null_map, lhs_null_map);
256	0	auto* __restrict rhs_null_map_tmp = create_null_map_column(temp_null_map, rhs_null_map);
257	0	auto* __restrict lhs_data_column_tmp = lhs_data_column;
258	0	auto* __restrict rhs_data_column_tmp = rhs_data_column;
259
260	0	do_null_pred<is_and_op>(lhs_data_column_tmp, lhs_null_map_tmp, rhs_data_column_tmp,
261	0	rhs_null_map_tmp, res_datas, res_nulls, size);
262
263	0	result_column = ColumnNullable::create(std::move(col_res), std::move(col_nulls));
264	0	}; Unexecuted instantiation: _ZZNK5doris13VCompoundPred14execute_columnEPNS_12VExprContextEPKNS_5BlockEPNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEmRNS_3COWINS_7IColumnEE13immutable_ptrISD_EEENKUlTnbvE0_clILb1EEEDav Unexecuted instantiation: _ZZNK5doris13VCompoundPred14execute_columnEPNS_12VExprContextEPKNS_5BlockEPNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEmRNS_3COWINS_7IColumnEE13immutable_ptrISD_EEENKUlTnbvE0_clILb0EEEDav
265
266		// false and NULL ----> 0
267		// true and NULL ----> NULL
268	0	if (_op == TExprOpcode::COMPOUND_AND) {
269		//1. not null column: all data is false
270		//2. nullable column: null map all is not null
271	0	if ((lhs_all_false && !lhs_is_nullable) \|\| (lhs_all_false && lhs_all_is_not_null)) {
272		// false and any = false, return lhs
273	0	return_result_column_id(lhs_column);
274	0	} else {
275	0	RETURN_IF_ERROR(get_rhs_colum());
276
277	0	if ((lhs_all_true && !lhs_is_nullable) \|\| //not null column
278	0	(lhs_all_true && lhs_all_is_not_null)) { //nullable column
279		// true and any = any, return rhs
280
281	0	return_result_column_id(rhs_column);
282	0	} else if ((rhs_all_false && !rhs_is_nullable) \|\|
283	0	(rhs_all_false && rhs_all_is_not_null)) {
284		// any and false = false, return rhs
285	0	return_result_column_id(rhs_column);
286	0	} else if ((rhs_all_true && !rhs_is_nullable) \|\|
287	0	(rhs_all_true && rhs_all_is_not_null)) {
288		// any and true = any, return lhs
289	0	return_result_column_id(lhs_column);
290	0	} else {
291	0	if (!result_is_nullable) {
292	0	vector_vector.template operator()<true>();
293	0	} else {
294	0	vector_vector_null.template operator()<true>();
295	0	}
296	0	}
297	0	}
298	0	} else if (_op == TExprOpcode::COMPOUND_OR) {
299		// true or NULL ----> 1
300		// false or NULL ----> NULL
301	0	if ((lhs_all_true && !lhs_is_nullable) \|\| (lhs_all_true && lhs_all_is_not_null)) {
302		// true or any = true, return lhs
303	0	return_result_column_id(lhs_column);
304	0	} else {
305	0	RETURN_IF_ERROR(get_rhs_colum());
306	0	if ((lhs_all_false && !lhs_is_nullable) \|\| (lhs_all_false && lhs_all_is_not_null)) {
307		// false or any = any, return rhs
308	0	return_result_column_id(rhs_column);
309	0	} else if ((rhs_all_true && !rhs_is_nullable) \|\|
310	0	(rhs_all_true && rhs_all_is_not_null)) {
311		// any or true = true, return rhs
312	0	return_result_column_id(rhs_column);
313	0	} else if ((rhs_all_false && !rhs_is_nullable) \|\|
314	0	(rhs_all_false && rhs_all_is_not_null)) {
315		// any or false = any, return lhs
316	0	return_result_column_id(lhs_column);
317	0	} else {
318	0	if (!result_is_nullable) {
319	0	vector_vector.template operator()<false>();
320	0	} else {
321	0	vector_vector_null.template operator()<false>();
322	0	}
323	0	}
324	0	}
325	0	} else {
326	0	return Status::InternalError("Compound operator must be AND or OR.");
327	0	}
328
329	0	DCHECK_EQ(result_column->size(), count);
330	0	return Status::OK();
331	0	}
332
333	0	double execute_cost() const override {
334	0	double cost = 0.3;
335	0	for (const auto& child : _children) {
336	0	cost += child->execute_cost();
337	0	}
338	0	return cost;
339	0	}
340
341		private:
342	0	static inline constexpr uint8_t apply_and_null(UInt8 a, UInt8 l_null, UInt8 b, UInt8 r_null) {
343		// (<> && false) is false, (true && NULL) is NULL
344	0	return (l_null & r_null) \| (r_null & (l_null ^ a)) \| (l_null & (r_null ^ b));
345	0	}
346	0	static inline constexpr uint8_t apply_or_null(UInt8 a, UInt8 l_null, UInt8 b, UInt8 r_null) {
347		// (<> \|\| true) is true, (false \|\| NULL) is NULL
348	0	return (l_null & r_null) \| (r_null & (r_null ^ a)) \| (l_null & (l_null ^ b));
349	0	}
350
351		template <bool is_and>
352	0	void static do_not_null_pred(uint8_t* __restrict lhs, uint8_t* __restrict rhs, size_t size) {
353		#ifdef NDEBUG
354		#if defined(__clang__)
355		#pragma clang loop vectorize(enable)
356		#elif defined(__GNUC__) && (__GNUC__ >= 5)
357		#pragma GCC ivdep
358		#endif
359		#endif
360	0	for (size_t i = 0; i < size; ++i) {
361	0	if constexpr (is_and) {
362	0	lhs[i] &= rhs[i];
363	0	} else {
364	0	lhs[i] \|= rhs[i];
365	0	}
366	0	}
367	0	} Unexecuted instantiation: _ZN5doris13VCompoundPred16do_not_null_predILb1EEEvPhS2_m Unexecuted instantiation: _ZN5doris13VCompoundPred16do_not_null_predILb0EEEvPhS2_m
368
369		template <bool is_and>
370		void static do_null_pred(uint8_t* __restrict lhs_data, uint8_t* __restrict lhs_null,
371		uint8_t* __restrict rhs_data, uint8_t* __restrict rhs_null,
372		uint8_t* __restrict res_data, uint8_t* __restrict res_null,
373	0	size_t size) {
374		#ifdef NDEBUG
375		#if defined(__clang__)
376		#pragma clang loop vectorize(enable)
377		#elif defined(__GNUC__) && (__GNUC__ >= 5)
378		#pragma GCC ivdep
379		#endif
380		#endif
381	0	for (size_t i = 0; i < size; ++i) {
382	0	if constexpr (is_and) {
383	0	res_null[i] = apply_and_null(lhs_data[i], lhs_null[i], rhs_data[i], rhs_null[i]);
384	0	res_data[i] = lhs_data[i] & rhs_data[i];
385	0	} else {
386	0	res_null[i] = apply_or_null(lhs_data[i], lhs_null[i], rhs_data[i], rhs_null[i]);
387	0	res_data[i] = lhs_data[i] \| rhs_data[i];
388	0	}
389	0	}
390	0	} Unexecuted instantiation: _ZN5doris13VCompoundPred12do_null_predILb1EEEvPhS2_S2_S2_S2_S2_m Unexecuted instantiation: _ZN5doris13VCompoundPred12do_null_predILb0EEEvPhS2_S2_S2_S2_S2_m
391
392	0	bool _has_const_child() const {
393	0	return std::ranges::any_of(_children,
394	0	[](const VExprSPtr& arg) -> bool { return arg->is_constant(); });
395	0	}
396
397		std::pair<uint8_t, uint8_t> _get_raw_data_and_null_map(ColumnPtr column,
398	0	bool has_nullable_column) const {
399	0	if (has_nullable_column) {
400	0	auto* nullable_column = assert_cast<ColumnNullable*>(column->assume_mutable().get());
401	0	auto* data_column =
402	0	assert_cast<ColumnUInt8*>(nullable_column->get_nested_column_ptr().get())
403	0	->get_data()
404	0	.data();
405	0	auto* null_map =
406	0	assert_cast<ColumnUInt8*>(nullable_column->get_null_map_column_ptr().get())
407	0	->get_data()
408	0	.data();
409	0	return std::make_pair(data_column, null_map);
410	0	} else {
411	0	auto* data_column =
412	0	assert_cast<ColumnUInt8*>(column->assume_mutable().get())->get_data().data();
413	0	return std::make_pair(data_column, nullptr);
414	0	}
415	0	}
416
417		TExprOpcode::type _op;
418		};
419
420		#include "common/compile_check_end.h"
421		} // namespace doris