This is an automated email from the ASF dual-hosted git repository.
zclll pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 16887609b5a [refine](expr) Expr execution does not depend on the
block's rows. (#58578)
16887609b5a is described below
commit 16887609b5af164fdd40d01fca8c2fd4dad112ae
Author: Mryange <[email protected]>
AuthorDate: Thu Dec 4 11:43:32 2025 +0800
[refine](expr) Expr execution does not depend on the block's rows. (#58578)
Previously, when executing an expr we relied on block.rows() to
determine the number of rows to return. That required guaranteeing the
block was not empty and that the first column (since block.rows() is
implemented from it) had the final desired row count. Now we pass a
count parameter to indicate the size each expr should return for its
Column.
before
```C++
vectorized::Block tmp_block;
tmp_block.insert({vectorized::ColumnUInt8::create(1),
std::make_shared<vectorized::DataTypeUInt8>(),
""});
RETURN_IF_ERROR(_const_expr_lists[_const_expr_list_idx][i]->execute(&tmp_block,
&result_list[i]));
```
now
```C++
RETURN_IF_ERROR(_const_expr_lists[_const_expr_list_idx][i]->execute_const_expr(
tmp_block_columns[i]));
Status VExprContext::execute_const_expr(ColumnWithTypeAndName& result) {
Status st;
RETURN_IF_CATCH_EXCEPTION({ st = _root->execute_column(this, nullptr,
1, result.column); });
```
---
be/src/pipeline/exec/union_source_operator.cpp | 15 ++++++-----
be/src/vec/exprs/lambda_function/lambda_function.h | 3 ++-
.../lambda_function/varray_filter_function.cpp | 7 ++---
.../exprs/lambda_function/varray_map_function.cpp | 14 +++++-----
.../exprs/lambda_function/varray_sort_function.cpp | 7 ++---
be/src/vec/exprs/vbitmap_predicate.cpp | 7 ++---
be/src/vec/exprs/vbitmap_predicate.h | 2 +-
be/src/vec/exprs/vbloom_predicate.cpp | 8 +++---
be/src/vec/exprs/vbloom_predicate.h | 2 +-
be/src/vec/exprs/vcase_expr.cpp | 13 ++++-----
be/src/vec/exprs/vcase_expr.h | 2 +-
be/src/vec/exprs/vcast_expr.cpp | 18 +++++++------
be/src/vec/exprs/vcast_expr.h | 4 +--
be/src/vec/exprs/vcolumn_ref.h | 3 ++-
be/src/vec/exprs/vcompound_pred.h | 9 ++++---
be/src/vec/exprs/vcondition_expr.cpp | 31 +++++++++++-----------
be/src/vec/exprs/vcondition_expr.h | 6 ++---
be/src/vec/exprs/vdirect_in_predicate.h | 16 +++++------
be/src/vec/exprs/vectorized_fn_call.cpp | 18 ++++++-------
be/src/vec/exprs/vectorized_fn_call.h | 8 +++---
be/src/vec/exprs/vexpr.cpp | 4 +--
be/src/vec/exprs/vexpr.h | 17 +++++++-----
be/src/vec/exprs/vexpr_context.cpp | 12 ++++++++-
be/src/vec/exprs/vexpr_context.h | 3 +++
be/src/vec/exprs/vin_predicate.cpp | 9 ++++---
be/src/vec/exprs/vin_predicate.h | 2 +-
be/src/vec/exprs/vinfo_func.cpp | 7 +++--
be/src/vec/exprs/vinfo_func.h | 2 +-
be/src/vec/exprs/virtual_slot_ref.cpp | 6 +++--
be/src/vec/exprs/virtual_slot_ref.h | 2 +-
be/src/vec/exprs/vlambda_function_call_expr.h | 5 ++--
be/src/vec/exprs/vlambda_function_expr.h | 4 +--
be/src/vec/exprs/vliteral.cpp | 6 ++---
be/src/vec/exprs/vliteral.h | 2 +-
be/src/vec/exprs/vmatch_predicate.cpp | 7 ++---
be/src/vec/exprs/vmatch_predicate.h | 2 +-
be/src/vec/exprs/vruntimefilter_wrapper.cpp | 7 ++---
be/src/vec/exprs/vruntimefilter_wrapper.h | 2 +-
be/src/vec/exprs/vsearch.cpp | 2 +-
be/src/vec/exprs/vsearch.h | 2 +-
be/src/vec/exprs/vslot_ref.cpp | 3 ++-
be/src/vec/exprs/vslot_ref.h | 2 +-
be/src/vec/exprs/vtopn_pred.h | 11 ++++----
be/test/exprs/mock_vexpr.h | 4 +--
be/test/exprs/virtual_slot_ref_test.cpp | 6 ++---
be/test/olap/collection_statistics_test.cpp | 2 +-
be/test/testutil/mock/mock_literal_expr.cpp | 4 +++
be/test/vec/exprs/try_cast_expr_test.cpp | 9 ++++++-
be/test/vec/exprs/vsearch_expr_test.cpp | 8 +++---
49 files changed, 198 insertions(+), 147 deletions(-)
diff --git a/be/src/pipeline/exec/union_source_operator.cpp
b/be/src/pipeline/exec/union_source_operator.cpp
index facacc48f24..38293f3cae0 100644
--- a/be/src/pipeline/exec/union_source_operator.cpp
+++ b/be/src/pipeline/exec/union_source_operator.cpp
@@ -27,7 +27,9 @@
#include "pipeline/exec/union_sink_operator.h"
#include "runtime/descriptors.h"
#include "util/defer_op.h"
+#include "vec/columns/column.h"
#include "vec/core/block.h"
+#include "vec/core/columns_with_type_and_name.h"
#include "vec/data_types/data_type_number.h" // IWYU pragma: keep
namespace doris {
@@ -152,24 +154,23 @@ Status UnionSourceOperatorX::get_next_const(RuntimeState*
state, vectorized::Blo
auto& _const_expr_list_idx = local_state._const_expr_list_idx;
vectorized::MutableBlock mblock =
vectorized::VectorizedUtils::build_mutable_mem_reuse_block(block,
row_descriptor());
+
+ vectorized::ColumnsWithTypeAndName tmp_block_columns;
for (; _const_expr_list_idx < _const_expr_lists.size() && mblock.rows() <
state->batch_size();
++_const_expr_list_idx) {
- vectorized::Block tmp_block;
- tmp_block.insert({vectorized::ColumnUInt8::create(1),
- std::make_shared<vectorized::DataTypeUInt8>(), ""});
int const_expr_lists_size =
cast_set<int>(_const_expr_lists[_const_expr_list_idx].size());
if (_const_expr_list_idx && const_expr_lists_size !=
_const_expr_lists[0].size()) {
return Status::InternalError(
"[UnionNode]const expr at {}'s count({}) not matched({}
expected)",
_const_expr_list_idx, const_expr_lists_size,
_const_expr_lists[0].size());
}
-
std::vector<int> result_list(const_expr_lists_size);
+ tmp_block_columns.resize(const_expr_lists_size);
for (size_t i = 0; i < const_expr_lists_size; ++i) {
-
RETURN_IF_ERROR(_const_expr_lists[_const_expr_list_idx][i]->execute(&tmp_block,
-
&result_list[i]));
+
RETURN_IF_ERROR(_const_expr_lists[_const_expr_list_idx][i]->execute_const_expr(
+ tmp_block_columns[i]));
}
- tmp_block.erase_not_in(result_list);
+ vectorized::Block tmp_block(tmp_block_columns);
if (tmp_block.columns() != mblock.columns()) {
return Status::InternalError(
"[UnionNode]columns count of const expr block not matched
({} vs {})",
diff --git a/be/src/vec/exprs/lambda_function/lambda_function.h
b/be/src/vec/exprs/lambda_function/lambda_function.h
index da83a662c73..4adec1c7de6 100644
--- a/be/src/vec/exprs/lambda_function/lambda_function.h
+++ b/be/src/vec/exprs/lambda_function/lambda_function.h
@@ -37,7 +37,8 @@ public:
}
virtual doris::Status execute(VExprContext* context, const
doris::vectorized::Block* block,
- ColumnPtr& result_column, const DataTypePtr&
result_type,
+ size_t count, ColumnPtr& result_column,
+ const DataTypePtr& result_type,
const VExprSPtrs& children) const = 0;
int batch_size;
diff --git a/be/src/vec/exprs/lambda_function/varray_filter_function.cpp
b/be/src/vec/exprs/lambda_function/varray_filter_function.cpp
index 23717eb6d10..108ac882e40 100644
--- a/be/src/vec/exprs/lambda_function/varray_filter_function.cpp
+++ b/be/src/vec/exprs/lambda_function/varray_filter_function.cpp
@@ -53,7 +53,8 @@ public:
std::string get_name() const override { return name; }
doris::Status execute(VExprContext* context, const
doris::vectorized::Block* block,
- ColumnPtr& result_column, const DataTypePtr&
result_type,
+ size_t output_count, ColumnPtr& result_column,
+ const DataTypePtr& result_type,
const VExprSPtrs& children) const override {
///* array_filter(array, array<boolean>) *///
@@ -61,9 +62,9 @@ public:
DCHECK_EQ(children.size(), 2);
ColumnPtr column_ptr_0;
- RETURN_IF_ERROR(children[0]->execute_column(context, block,
column_ptr_0));
+ RETURN_IF_ERROR(children[0]->execute_column(context, block,
output_count, column_ptr_0));
ColumnPtr column_ptr_1;
- RETURN_IF_ERROR(children[1]->execute_column(context, block,
column_ptr_1));
+ RETURN_IF_ERROR(children[1]->execute_column(context, block,
output_count, column_ptr_1));
//2. get first and second array column
auto first_column = column_ptr_0->convert_to_full_column_if_const();
diff --git a/be/src/vec/exprs/lambda_function/varray_map_function.cpp
b/be/src/vec/exprs/lambda_function/varray_map_function.cpp
index 914ec6eb930..e4281724533 100644
--- a/be/src/vec/exprs/lambda_function/varray_map_function.cpp
+++ b/be/src/vec/exprs/lambda_function/varray_map_function.cpp
@@ -77,8 +77,9 @@ public:
std::string get_name() const override { return name; }
- Status execute(VExprContext* context, const vectorized::Block* block,
ColumnPtr& result_column,
- const DataTypePtr& result_type, const VExprSPtrs& children)
const override {
+ Status execute(VExprContext* context, const vectorized::Block* block,
size_t count,
+ ColumnPtr& result_column, const DataTypePtr& result_type,
+ const VExprSPtrs& children) const override {
LambdaArgs args_info;
// collect used slot ref in lambda function body
std::vector<int>& output_slot_ref_indexs =
args_info.output_slot_ref_indexs;
@@ -111,7 +112,7 @@ public:
ColumnsWithTypeAndName arguments(children.size() - 1);
for (int i = 1; i < children.size(); ++i) {
ColumnPtr column;
- RETURN_IF_ERROR(children[i]->execute_column(context, block,
column));
+ RETURN_IF_ERROR(children[i]->execute_column(context, block, count,
column));
arguments[i - 1].column = column;
arguments[i - 1].type = children[i]->execute_type(block);
arguments[i - 1].name = children[i]->expr_name();
@@ -264,7 +265,7 @@ public:
//current row is end of array, move to next row
args_info.current_row_idx++;
args_info.current_offset_in_array = 0;
- if (args_info.current_row_idx >= block->rows()) {
+ if (args_info.current_row_idx >= count) {
break;
}
args_info.current_row_eos = false;
@@ -283,7 +284,8 @@ public:
//3. child[0]->execute(new_block)
ColumnPtr res_col;
- RETURN_IF_ERROR(children[0]->execute_column(context,
&lambda_block, res_col));
+ RETURN_IF_ERROR(children[0]->execute_column(context,
&lambda_block, lambda_block.rows(),
+ res_col));
res_col = res_col->convert_to_full_column_if_const();
res_type = children[0]->execute_type(&lambda_block);
@@ -292,7 +294,7 @@ public:
}
result_col->insert_range_from(*res_col, 0, res_col->size());
lambda_block.clear_column_data(column_size);
- } while (args_info.current_row_idx < block->rows());
+ } while (args_info.current_row_idx < count);
//4. get the result column after execution, reassemble it into a new
array column, and return.
if (result_type->is_nullable()) {
diff --git a/be/src/vec/exprs/lambda_function/varray_sort_function.cpp
b/be/src/vec/exprs/lambda_function/varray_sort_function.cpp
index 1cffdcd5ea7..d894d04359a 100644
--- a/be/src/vec/exprs/lambda_function/varray_sort_function.cpp
+++ b/be/src/vec/exprs/lambda_function/varray_sort_function.cpp
@@ -67,15 +67,16 @@ public:
std::string get_name() const override { return name; }
- Status execute(VExprContext* context, const vectorized::Block* block,
ColumnPtr& result_column,
- const DataTypePtr& result_type, const VExprSPtrs& children)
const override {
+ Status execute(VExprContext* context, const vectorized::Block* block,
size_t count,
+ ColumnPtr& result_column, const DataTypePtr& result_type,
+ const VExprSPtrs& children) const override {
///* array_sort(lambda, arg) *///
DCHECK_EQ(children.size(), 2);
// 1. get data, we need to obtain this actual data and type.
ColumnPtr column_ptr;
- RETURN_IF_ERROR(children[1]->execute_column(context, block,
column_ptr));
+ RETURN_IF_ERROR(children[1]->execute_column(context, block, count,
column_ptr));
DataTypePtr type_ptr = children[1]->execute_type(block);
auto column = column_ptr->convert_to_full_column_if_const();
diff --git a/be/src/vec/exprs/vbitmap_predicate.cpp
b/be/src/vec/exprs/vbitmap_predicate.cpp
index 775cc5b6faf..08883b718b0 100644
--- a/be/src/vec/exprs/vbitmap_predicate.cpp
+++ b/be/src/vec/exprs/vbitmap_predicate.cpp
@@ -75,17 +75,17 @@ doris::Status
vectorized::VBitmapPredicate::open(doris::RuntimeState* state,
return Status::OK();
}
-Status VBitmapPredicate::execute_column(VExprContext* context, const Block*
block,
+Status VBitmapPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col);
DCHECK_EQ(_children.size(), 1);
ColumnPtr argument_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block,
argument_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
argument_column));
argument_column = argument_column->convert_to_full_column_if_const();
size_t sz = argument_column->size();
- auto res_data_column = ColumnUInt8::create(block->rows());
+ auto res_data_column = ColumnUInt8::create(sz);
res_data_column->resize(sz);
auto* ptr = res_data_column->get_data().data();
@@ -101,6 +101,7 @@ Status VBitmapPredicate::execute_column(VExprContext*
context, const Block* bloc
}
result_column = std::move(res_data_column);
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vbitmap_predicate.h
b/be/src/vec/exprs/vbitmap_predicate.h
index b2a56e9294d..a1ed72825b0 100644
--- a/be/src/vec/exprs/vbitmap_predicate.h
+++ b/be/src/vec/exprs/vbitmap_predicate.h
@@ -49,7 +49,7 @@ public:
~VBitmapPredicate() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
diff --git a/be/src/vec/exprs/vbloom_predicate.cpp
b/be/src/vec/exprs/vbloom_predicate.cpp
index dfe9102795f..2eff5ee016f 100644
--- a/be/src/vec/exprs/vbloom_predicate.cpp
+++ b/be/src/vec/exprs/vbloom_predicate.cpp
@@ -70,23 +70,25 @@ void VBloomPredicate::close(VExprContext* context,
FunctionContext::FunctionStat
VExpr::close(context, scope);
}
-Status VBloomPredicate::execute_column(VExprContext* context, const Block*
block,
+Status VBloomPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col);
DCHECK_EQ(_children.size(), 1);
ColumnPtr argument_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block,
argument_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
argument_column));
argument_column = argument_column->convert_to_full_column_if_const();
- auto res_data_column = ColumnUInt8::create(block->rows());
size_t sz = argument_column->size();
+ auto res_data_column = ColumnUInt8::create(sz);
+
res_data_column->resize(sz);
auto* ptr = ((ColumnUInt8*)res_data_column.get())->get_data().data();
_filter->find_fixed_len(argument_column, ptr);
result_column = std::move(res_data_column);
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vbloom_predicate.h
b/be/src/vec/exprs/vbloom_predicate.h
index 746d2a03033..e7a1350d9a3 100644
--- a/be/src/vec/exprs/vbloom_predicate.h
+++ b/be/src/vec/exprs/vbloom_predicate.h
@@ -43,7 +43,7 @@ class VBloomPredicate final : public VExpr {
public:
VBloomPredicate(const TExprNode& node);
~VBloomPredicate() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
diff --git a/be/src/vec/exprs/vcase_expr.cpp b/be/src/vec/exprs/vcase_expr.cpp
index 2c52c6f4073..d4065a99122 100644
--- a/be/src/vec/exprs/vcase_expr.cpp
+++ b/be/src/vec/exprs/vcase_expr.cpp
@@ -76,21 +76,21 @@ void VCaseExpr::close(VExprContext* context,
FunctionContext::FunctionStateScope
VExpr::close(context, scope);
}
-Status VCaseExpr::execute_column(VExprContext* context, const Block* block,
+Status VCaseExpr::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
if (is_const_and_have_executed()) { // const have execute in open function
- result_column = get_result_from_const(block);
+ result_column = get_result_from_const(count);
return Status::OK();
}
DCHECK(_open_finished || _getting_const_col);
- size_t rows_count = block->rows();
+ size_t rows_count = count;
std::vector<ColumnPtr> when_columns;
std::vector<ColumnPtr> then_columns;
if (_has_else_expr) {
ColumnPtr else_column_ptr;
- RETURN_IF_ERROR(_children.back()->execute_column(context, block,
else_column_ptr));
+ RETURN_IF_ERROR(_children.back()->execute_column(context, block,
count, else_column_ptr));
then_columns.emplace_back(else_column_ptr);
} else {
then_columns.emplace_back(nullptr);
@@ -98,13 +98,13 @@ Status VCaseExpr::execute_column(VExprContext* context,
const Block* block,
for (int i = 0; i < _children.size() - _has_else_expr; i += 2) {
ColumnPtr when_column_ptr;
- RETURN_IF_ERROR(_children[i]->execute_column(context, block,
when_column_ptr));
+ RETURN_IF_ERROR(_children[i]->execute_column(context, block, count,
when_column_ptr));
if (calculate_false_number(when_column_ptr) == rows_count) {
continue;
}
when_columns.emplace_back(when_column_ptr);
ColumnPtr then_column_ptr;
- RETURN_IF_ERROR(_children[i + 1]->execute_column(context, block,
then_column_ptr));
+ RETURN_IF_ERROR(_children[i + 1]->execute_column(context, block,
count, then_column_ptr));
then_columns.emplace_back(then_column_ptr);
}
@@ -116,6 +116,7 @@ Status VCaseExpr::execute_column(VExprContext* context,
const Block* block,
} else {
result_column = _execute_impl<uint8_t>(when_columns, then_columns,
rows_count);
}
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vcase_expr.h b/be/src/vec/exprs/vcase_expr.h
index f77b895fe1d..c669abc0967 100644
--- a/be/src/vec/exprs/vcase_expr.h
+++ b/be/src/vec/exprs/vcase_expr.h
@@ -52,7 +52,7 @@ class VCaseExpr final : public VExpr {
public:
VCaseExpr(const TExprNode& node);
~VCaseExpr() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
diff --git a/be/src/vec/exprs/vcast_expr.cpp b/be/src/vec/exprs/vcast_expr.cpp
index ca2bb9057b4..bf76a3988b7 100644
--- a/be/src/vec/exprs/vcast_expr.cpp
+++ b/be/src/vec/exprs/vcast_expr.cpp
@@ -105,26 +105,27 @@ void VCastExpr::close(VExprContext* context,
FunctionContext::FunctionStateScope
VExpr::close(context, scope);
}
-Status VCastExpr::execute_column(VExprContext* context, const Block* block,
+Status VCastExpr::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col)
<< _open_finished << _getting_const_col << _expr_name;
if (is_const_and_have_executed()) { // const have executed in open function
- result_column = get_result_from_const(block);
+ result_column = get_result_from_const(count);
return Status::OK();
}
// for each child call execute
ColumnPtr from_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block, from_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
from_column));
Block temp_block;
temp_block.insert({from_column, _children[0]->execute_type(block),
_children[0]->expr_name()});
temp_block.insert({nullptr, _data_type, _expr_name});
RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index),
temp_block, {0}, 1,
- block->rows()));
+ temp_block.rows()));
result_column = temp_block.get_by_position(1).column;
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
@@ -145,12 +146,12 @@ DataTypePtr TryCastExpr::original_cast_return_type()
const {
}
}
-Status TryCastExpr::execute_column(VExprContext* context, const Block* block,
+Status TryCastExpr::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col)
<< _open_finished << _getting_const_col << _expr_name;
if (is_const_and_have_executed()) { // const have executed in open function
- result_column = get_result_from_const(block);
+ result_column = get_result_from_const(count);
return Status::OK();
}
@@ -159,7 +160,7 @@ Status TryCastExpr::execute_column(VExprContext* context,
const Block* block,
// execute child first
ColumnPtr from_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block, from_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
from_column));
auto from_type = _children[0]->execute_type(block);
// prepare block
@@ -170,7 +171,7 @@ Status TryCastExpr::execute_column(VExprContext* context,
const Block* block,
// batch execute
auto batch_exec_status =
_function->execute(context->fn_context(_fn_context_index), temp_block,
- {0}, 1, block->rows());
+ {0}, 1, temp_block.rows());
// If batch is executed successfully,
// it means that there is no error and it will be returned directly.
if (batch_exec_status.ok()) {
@@ -195,6 +196,7 @@ Status TryCastExpr::execute_column(VExprContext* context,
const Block* block,
}
// wrap nullable
result_column = make_nullable(result_column);
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vcast_expr.h b/be/src/vec/exprs/vcast_expr.h
index 663f2c4b6ed..fb652848fd5 100644
--- a/be/src/vec/exprs/vcast_expr.h
+++ b/be/src/vec/exprs/vcast_expr.h
@@ -48,7 +48,7 @@ public:
#endif
VCastExpr(const TExprNode& node) : VExpr(node) {}
~VCastExpr() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
@@ -83,7 +83,7 @@ public:
TryCastExpr(const TExprNode& node)
: VCastExpr(node),
_original_cast_return_is_nullable(node.is_cast_nullable) {}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
~TryCastExpr() override = default;
std::string cast_name() const override { return "TRY CAST"; }
diff --git a/be/src/vec/exprs/vcolumn_ref.h b/be/src/vec/exprs/vcolumn_ref.h
index 123b9785e71..3429cabf6f3 100644
--- a/be/src/vec/exprs/vcolumn_ref.h
+++ b/be/src/vec/exprs/vcolumn_ref.h
@@ -57,10 +57,11 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
DCHECK(_open_finished || _getting_const_col);
result_column = block->get_by_position(_column_id + _gap).column;
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vcompound_pred.h
b/be/src/vec/exprs/vcompound_pred.h
index 604a23a2680..c1ba88fa2af 100644
--- a/be/src/vec/exprs/vcompound_pred.h
+++ b/be/src/vec/exprs/vcompound_pred.h
@@ -152,17 +152,17 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
if (fast_execute(context, result_column)) {
return Status::OK();
}
if (get_num_children() == 1 || _has_const_child()) {
- return VectorizedFnCall::execute_column(context, block,
result_column);
+ return VectorizedFnCall::execute_column(context, block, count,
result_column);
}
ColumnPtr lhs_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block,
lhs_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
lhs_column));
lhs_column = lhs_column->convert_to_full_column_if_const();
size_t size = lhs_column->size();
@@ -190,7 +190,7 @@ public:
auto get_rhs_colum = [&]() {
if (!rhs_column) {
- RETURN_IF_ERROR(_children[1]->execute_column(context, block,
rhs_column));
+ RETURN_IF_ERROR(_children[1]->execute_column(context, block,
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);
@@ -343,6 +343,7 @@ public:
return Status::InternalError("Compound operator must be AND or
OR.");
}
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vcondition_expr.cpp
b/be/src/vec/exprs/vcondition_expr.cpp
index 630c968b8e0..4475658612d 100644
--- a/be/src/vec/exprs/vcondition_expr.cpp
+++ b/be/src/vec/exprs/vcondition_expr.cpp
@@ -445,13 +445,13 @@ Status VectorizedIfExpr::_execute_impl_internal(Block&
block, const ColumnNumber
}
}
-Status VectorizedIfExpr::execute_column(VExprContext* context, const Block*
block,
+Status VectorizedIfExpr::execute_column(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col) << debug_string();
DCHECK_EQ(_children.size(), 3) << "IF expr must have three children";
ColumnPtr cond_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block, cond_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
cond_column));
ColumnPtr then_column;
ColumnPtr else_column;
@@ -459,17 +459,17 @@ Status VectorizedIfExpr::execute_column(VExprContext*
context, const Block* bloc
auto true_count = count_true_with_notnull(cond_column);
auto item_count = cond_column->size();
if (true_count == item_count) {
- RETURN_IF_ERROR(_children[1]->execute_column(context, block,
then_column));
+ RETURN_IF_ERROR(_children[1]->execute_column(context, block, count,
then_column));
result_column = _data_type->is_nullable() ? make_nullable(then_column)
: then_column;
return Status::OK();
} else if (true_count == 0) {
- RETURN_IF_ERROR(_children[2]->execute_column(context, block,
else_column));
+ RETURN_IF_ERROR(_children[2]->execute_column(context, block, count,
else_column));
result_column = _data_type->is_nullable() ? make_nullable(else_column)
: else_column;
return Status::OK();
}
- RETURN_IF_ERROR(_children[1]->execute_column(context, block, then_column));
- RETURN_IF_ERROR(_children[2]->execute_column(context, block, else_column));
+ RETURN_IF_ERROR(_children[1]->execute_column(context, block, count,
then_column));
+ RETURN_IF_ERROR(_children[2]->execute_column(context, block, count,
else_column));
Block temp_block;
@@ -481,17 +481,17 @@ Status VectorizedIfExpr::execute_column(VExprContext*
context, const Block* bloc
temp_block.insert({nullptr, _data_type, IF_NAME});
RETURN_IF_ERROR(_execute_impl_internal(temp_block, {0, 1, 2}, 3,
temp_block.rows()));
result_column = temp_block.get_by_position(3).column;
- RETURN_IF_ERROR(block->check_type_and_column());
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
-Status VectorizedIfNullExpr::execute_column(VExprContext* context, const
Block* block,
+Status VectorizedIfNullExpr::execute_column(VExprContext* context, const
Block* block, size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col) << debug_string();
DCHECK_EQ(_children.size(), 2) << "IFNULL expr must have two children";
ColumnPtr first_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block,
first_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
first_column));
first_column = first_column->convert_to_full_column_if_const();
if (!first_column->is_nullable()) {
@@ -501,12 +501,12 @@ Status VectorizedIfNullExpr::execute_column(VExprContext*
context, const Block*
}
if (first_column->only_null()) {
- RETURN_IF_ERROR(_children[1]->execute_column(context, block,
result_column));
+ RETURN_IF_ERROR(_children[1]->execute_column(context, block, count,
result_column));
return Status::OK();
}
ColumnPtr second_column;
- RETURN_IF_ERROR(_children[1]->execute_column(context, block,
second_column));
+ RETURN_IF_ERROR(_children[1]->execute_column(context, block, count,
second_column));
const auto& nullable_first_column = assert_cast<const
ColumnNullable&>(*first_column);
@@ -534,7 +534,7 @@ Status VectorizedIfNullExpr::execute_column(VExprContext*
context, const Block*
temp_block.insert({nullptr, _data_type, IF_NULL_NAME});
RETURN_IF_ERROR(_execute_impl_internal(temp_block, {0, 1, 2}, 3,
temp_block.rows()));
result_column = temp_block.get_by_position(3).column;
- RETURN_IF_ERROR(block->check_type_and_column());
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
@@ -612,9 +612,9 @@ Status filled_result_column(const DataTypePtr& data_type,
MutableColumnPtr& resu
}
Status VectorizedCoalesceExpr::execute_column(VExprContext* context, const
Block* block,
- ColumnPtr& return_column) const {
+ size_t count, ColumnPtr&
return_column) const {
DataTypePtr result_type = _data_type;
- const auto input_rows_count = block->rows();
+ const auto input_rows_count = count;
size_t remaining_rows = input_rows_count;
std::vector<uint32_t> record_idx(
@@ -669,7 +669,7 @@ Status VectorizedCoalesceExpr::execute_column(VExprContext*
context, const Block
for (size_t i = 0; i < _children.size() && remaining_rows; ++i) {
// Execute child expression to get the argument column.
- RETURN_IF_ERROR(_children[i]->execute_column(context, block,
original_columns[i]));
+ RETURN_IF_ERROR(_children[i]->execute_column(context, block, count,
original_columns[i]));
original_columns[i] =
original_columns[i]->convert_to_full_column_if_const();
argument_not_null_columns[i] = original_columns[i];
if (const auto* nullable =
@@ -736,6 +736,7 @@ Status VectorizedCoalesceExpr::execute_column(VExprContext*
context, const Block
return_column = std::move(result_column);
}
+ DCHECK_EQ(return_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vcondition_expr.h
b/be/src/vec/exprs/vcondition_expr.h
index fa119909bd3..3605aab2094 100644
--- a/be/src/vec/exprs/vcondition_expr.h
+++ b/be/src/vec/exprs/vcondition_expr.h
@@ -61,7 +61,7 @@ class VectorizedIfExpr : public VConditionExpr {
public:
VectorizedIfExpr(const TExprNode& node) : VConditionExpr(node) {}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
const std::string& expr_name() const override { return IF_NAME; }
@@ -125,7 +125,7 @@ public:
const std::string& expr_name() const override { return IF_NULL_NAME; }
inline static const std::string IF_NULL_NAME = "ifnull";
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
};
@@ -133,7 +133,7 @@ class VectorizedCoalesceExpr : public VConditionExpr {
ENABLE_FACTORY_CREATOR(VectorizedCoalesceExpr);
public:
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
VectorizedCoalesceExpr(const TExprNode& node) : VConditionExpr(node) {}
const std::string& expr_name() const override { return NAME; }
diff --git a/be/src/vec/exprs/vdirect_in_predicate.h
b/be/src/vec/exprs/vdirect_in_predicate.h
index bcc8714e0e6..67fc455d4db 100644
--- a/be/src/vec/exprs/vdirect_in_predicate.h
+++ b/be/src/vec/exprs/vdirect_in_predicate.h
@@ -54,14 +54,14 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
- return _do_execute(context, block, result_column, nullptr);
+ return _do_execute(context, block, count, result_column, nullptr);
}
- Status execute_runtime_filter(VExprContext* context, const Block* block,
+ Status execute_runtime_filter(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const override {
- return _do_execute(context, block, result_column, arg_column);
+ return _do_execute(context, block, count, result_column, arg_column);
}
const std::string& expr_name() const override { return _expr_name; }
@@ -109,12 +109,12 @@ public:
uint64_t get_digest(uint64_t seed) const override { return 0; }
private:
- Status _do_execute(VExprContext* context, const Block* block, ColumnPtr&
result_column,
- ColumnPtr* arg_column) const {
+ Status _do_execute(VExprContext* context, const Block* block, size_t count,
+ ColumnPtr& result_column, ColumnPtr* arg_column) const {
DCHECK(_open_finished || _getting_const_col);
ColumnPtr argument_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block,
argument_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
argument_column));
argument_column = argument_column->convert_to_full_column_if_const();
if (arg_column != nullptr) {
@@ -122,7 +122,7 @@ private:
}
size_t sz = argument_column->size();
- auto res_data_column = ColumnUInt8::create(block->rows());
+ auto res_data_column = ColumnUInt8::create(sz);
res_data_column->resize(sz);
if (argument_column->is_nullable()) {
diff --git a/be/src/vec/exprs/vectorized_fn_call.cpp
b/be/src/vec/exprs/vectorized_fn_call.cpp
index c551254487a..6e97783f843 100644
--- a/be/src/vec/exprs/vectorized_fn_call.cpp
+++ b/be/src/vec/exprs/vectorized_fn_call.cpp
@@ -184,10 +184,10 @@ Status
VectorizedFnCall::evaluate_inverted_index(VExprContext* context, uint32_t
return _evaluate_inverted_index(context, _function, segment_num_rows);
}
-Status VectorizedFnCall::_do_execute(VExprContext* context, const Block* block,
+Status VectorizedFnCall::_do_execute(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const {
if (is_const_and_have_executed()) { // const have executed in open function
- result_column = get_result_from_const(block);
+ result_column = get_result_from_const(count);
return Status::OK();
}
if (fast_execute(context, result_column)) {
@@ -218,7 +218,7 @@ Status VectorizedFnCall::_do_execute(VExprContext* context,
const Block* block,
for (int i = 0; i < _children.size(); ++i) {
ColumnPtr tmp_arg_column;
- RETURN_IF_ERROR(_children[i]->execute_column(context, block,
tmp_arg_column));
+ RETURN_IF_ERROR(_children[i]->execute_column(context, block, count,
tmp_arg_column));
auto arg_type = _children[i]->execute_type(block);
temp_block.insert({tmp_arg_column, arg_type,
_children[i]->expr_name()});
args[i] = i;
@@ -242,9 +242,9 @@ Status VectorizedFnCall::_do_execute(VExprContext* context,
const Block* block,
});
RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index),
temp_block, args,
- num_columns_without_result,
block->rows()));
+ num_columns_without_result, count));
result_column =
temp_block.get_by_position(num_columns_without_result).column;
- RETURN_IF_ERROR(block->check_type_and_column());
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
@@ -267,14 +267,14 @@ size_t VectorizedFnCall::estimate_memory(const size_t
rows) {
}
Status VectorizedFnCall::execute_runtime_filter(VExprContext* context, const
Block* block,
- ColumnPtr& result_column,
+ size_t count, ColumnPtr&
result_column,
ColumnPtr* arg_column) const {
- return _do_execute(context, block, result_column, arg_column);
+ return _do_execute(context, block, count, result_column, arg_column);
}
-Status VectorizedFnCall::execute_column(VExprContext* context, const Block*
block,
+Status VectorizedFnCall::execute_column(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column) const {
- return _do_execute(context, block, result_column, nullptr);
+ return _do_execute(context, block, count, result_column, nullptr);
}
const std::string& VectorizedFnCall::expr_name() const {
diff --git a/be/src/vec/exprs/vectorized_fn_call.h
b/be/src/vec/exprs/vectorized_fn_call.h
index cc5ee1d030a..f5cc630f8e9 100644
--- a/be/src/vec/exprs/vectorized_fn_call.h
+++ b/be/src/vec/exprs/vectorized_fn_call.h
@@ -52,9 +52,9 @@ public:
VectorizedFnCall() = default;
#endif
VectorizedFnCall(const TExprNode& node);
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
- Status execute_runtime_filter(VExprContext* context, const Block* block,
+ Status execute_runtime_filter(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const override;
Status evaluate_inverted_index(VExprContext* context, uint32_t
segment_num_rows) override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
@@ -101,8 +101,8 @@ protected:
std::string _function_name;
private:
- Status _do_execute(VExprContext* context, const Block* block, ColumnPtr&
result_column,
- ColumnPtr* arg_column) const;
+ Status _do_execute(VExprContext* context, const Block* block, size_t count,
+ ColumnPtr& result_column, ColumnPtr* arg_column) const;
};
#include "common/compile_check_end.h"
diff --git a/be/src/vec/exprs/vexpr.cpp b/be/src/vec/exprs/vexpr.cpp
index a845458f09c..862cef196fd 100644
--- a/be/src/vec/exprs/vexpr.cpp
+++ b/be/src/vec/exprs/vexpr.cpp
@@ -837,8 +837,8 @@ uint64_t VExpr::get_digest(uint64_t seed) const {
return digest;
}
-ColumnPtr VExpr::get_result_from_const(const Block* block) const {
- return ColumnConst::create(_constant_col->column_ptr, block->rows());
+ColumnPtr VExpr::get_result_from_const(size_t count) const {
+ return ColumnConst::create(_constant_col->column_ptr, count);
}
Status VExpr::_evaluate_inverted_index(VExprContext* context, const
FunctionBasePtr& function,
diff --git a/be/src/vec/exprs/vexpr.h b/be/src/vec/exprs/vexpr.h
index 35a0d3733b0..e073106c1b3 100644
--- a/be/src/vec/exprs/vexpr.h
+++ b/be/src/vec/exprs/vexpr.h
@@ -133,14 +133,19 @@ public:
virtual Status execute(VExprContext* context, Block* block, int*
result_column_id) const {
ColumnPtr result_column;
- RETURN_IF_ERROR(execute_column(context, block, result_column));
+ RETURN_IF_ERROR(execute_column(context, block, block->rows(),
result_column));
*result_column_id = block->columns();
block->insert({result_column, execute_type(block), expr_name()});
return Status::OK();
}
- // execute current expr and return result column
- virtual Status execute_column(VExprContext* context, const Block* block,
+ // 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.
+ virtual Status execute_column(VExprContext* context, const Block* block,
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.
@@ -165,9 +170,9 @@ public:
// 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,
+ virtual Status execute_runtime_filter(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const {
- return execute_column(context, block, result_column);
+ return execute_column(context, block, count, result_column);
};
/// Subclasses overriding this function should call VExpr::Close().
@@ -365,7 +370,7 @@ protected:
return (is_constant() && (_constant_col != nullptr));
}
- ColumnPtr get_result_from_const(const Block* block) const;
+ ColumnPtr get_result_from_const(size_t count) const;
Status check_constant(const Block& block, ColumnNumbers arguments) const;
diff --git a/be/src/vec/exprs/vexpr_context.cpp
b/be/src/vec/exprs/vexpr_context.cpp
index a7b71b77646..7939201d76b 100644
--- a/be/src/vec/exprs/vexpr_context.cpp
+++ b/be/src/vec/exprs/vexpr_context.cpp
@@ -76,7 +76,8 @@ Status VExprContext::execute(vectorized::Block* block, int*
result_column_id) {
Status VExprContext::execute(const Block* block, ColumnPtr& result_column) {
Status st;
- RETURN_IF_CATCH_EXCEPTION({ st = _root->execute_column(this, block,
result_column); });
+ RETURN_IF_CATCH_EXCEPTION(
+ { st = _root->execute_column(this, block, block->rows(),
result_column); });
return st;
}
@@ -84,6 +85,15 @@ DataTypePtr VExprContext::execute_type(const Block* block) {
return _root->execute_type(block);
}
+Status VExprContext::execute_const_expr(ColumnWithTypeAndName& result) {
+ Status st;
+ RETURN_IF_CATCH_EXCEPTION({ st = _root->execute_column(this, nullptr, 1,
result.column); });
+ RETURN_IF_ERROR(st);
+ result.type = _root->execute_type(nullptr);
+ result.name = _root->expr_name();
+ return Status::OK();
+}
+
[[nodiscard]] const std::string& VExprContext::expr_name() const {
return _root->expr_name();
}
diff --git a/be/src/vec/exprs/vexpr_context.h b/be/src/vec/exprs/vexpr_context.h
index 3179526ec54..73720abaed3 100644
--- a/be/src/vec/exprs/vexpr_context.h
+++ b/be/src/vec/exprs/vexpr_context.h
@@ -36,6 +36,7 @@
#include "udf/udf.h"
#include "vec/columns/column.h"
#include "vec/core/block.h"
+#include "vec/core/column_with_type_and_name.h"
#include "vec/exprs/vexpr_fwd.h"
namespace doris {
@@ -177,6 +178,8 @@ public:
[[nodiscard]] const std::string& expr_name() const;
[[nodiscard]] bool is_blockable() const;
+ [[nodiscard]] Status execute_const_expr(ColumnWithTypeAndName& result);
+
VExprSPtr root() { return _root; }
void set_root(const VExprSPtr& expr) { _root = expr; }
void set_index_context(std::shared_ptr<IndexExecContext> index_context) {
diff --git a/be/src/vec/exprs/vin_predicate.cpp
b/be/src/vec/exprs/vin_predicate.cpp
index a35d401cbe2..26e1b943eeb 100644
--- a/be/src/vec/exprs/vin_predicate.cpp
+++ b/be/src/vec/exprs/vin_predicate.cpp
@@ -114,10 +114,10 @@ Status
VInPredicate::evaluate_inverted_index(VExprContext* context, uint32_t seg
return _evaluate_inverted_index(context, _function, segment_num_rows);
}
-Status VInPredicate::execute_column(VExprContext* context, const Block* block,
+Status VInPredicate::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
if (is_const_and_have_executed()) { // const have execute in open function
- result_column = get_result_from_const(block);
+ result_column = get_result_from_const(count);
return Status::OK();
}
if (fast_execute(context, result_column)) {
@@ -135,7 +135,7 @@ Status VInPredicate::execute_column(VExprContext* context,
const Block* block,
Block temp_block;
for (int i = 0; i < args_size; ++i) {
ColumnPtr column;
- RETURN_IF_ERROR(_children[i]->execute_column(context, block, column));
+ RETURN_IF_ERROR(_children[i]->execute_column(context, block, count,
column));
arguments.push_back(i);
temp_block.insert({column, _children[i]->execute_type(block),
_children[i]->expr_name()});
}
@@ -144,8 +144,9 @@ Status VInPredicate::execute_column(VExprContext* context,
const Block* block,
temp_block.insert({nullptr, _data_type, _expr_name});
RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index),
temp_block,
- arguments, num_columns_without_result,
block->rows()));
+ arguments, num_columns_without_result,
temp_block.rows()));
result_column =
temp_block.get_by_position(num_columns_without_result).column;
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vin_predicate.h b/be/src/vec/exprs/vin_predicate.h
index 38eb2a2e9e3..f3d3cd3ad3e 100644
--- a/be/src/vec/exprs/vin_predicate.h
+++ b/be/src/vec/exprs/vin_predicate.h
@@ -45,7 +45,7 @@ public:
VInPredicate() = default;
#endif
~VInPredicate() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
size_t estimate_memory(const size_t rows) override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
diff --git a/be/src/vec/exprs/vinfo_func.cpp b/be/src/vec/exprs/vinfo_func.cpp
index d631daa64bb..9020c1e8206 100644
--- a/be/src/vec/exprs/vinfo_func.cpp
+++ b/be/src/vec/exprs/vinfo_func.cpp
@@ -55,11 +55,10 @@ VInfoFunc::VInfoFunc(const TExprNode& node) : VExpr(node) {
this->_column_ptr = _data_type->create_column_const(1, field);
}
-Status VInfoFunc::execute_column(VExprContext* context, const Block* block,
+Status VInfoFunc::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
- // Info function should return least one row, e.g. select current_user().
- size_t row_size = std::max(block->rows(), _column_ptr->size());
- result_column = _column_ptr->clone_resized(row_size);
+ result_column = _column_ptr->clone_resized(count);
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vinfo_func.h b/be/src/vec/exprs/vinfo_func.h
index 8aa8d37e3a2..a2c020a697c 100644
--- a/be/src/vec/exprs/vinfo_func.h
+++ b/be/src/vec/exprs/vinfo_func.h
@@ -39,7 +39,7 @@ public:
~VInfoFunc() override = default;
const std::string& expr_name() const override { return _expr_name; }
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
private:
diff --git a/be/src/vec/exprs/virtual_slot_ref.cpp
b/be/src/vec/exprs/virtual_slot_ref.cpp
index a2f090cf76f..a7b154a203a 100644
--- a/be/src/vec/exprs/virtual_slot_ref.cpp
+++ b/be/src/vec/exprs/virtual_slot_ref.cpp
@@ -103,7 +103,7 @@ Status VirtualSlotRef::open(RuntimeState* state,
VExprContext* context,
return Status::OK();
}
-Status VirtualSlotRef::execute_column(VExprContext* context, const Block*
block,
+Status VirtualSlotRef::execute_column(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column) const {
if (_column_id >= 0 && _column_id >= block->columns()) {
return Status::Error<ErrorCode::INTERNAL_ERROR>(
@@ -129,7 +129,8 @@ Status VirtualSlotRef::execute_column(VExprContext*
context, const Block* block,
// Note: After executing 'execute', we cannot use the column from
line 120 in subsequent code,
// because the vector might be resized during execution, causing
previous references to become invalid.
ColumnPtr tmp_column;
- RETURN_IF_ERROR(_virtual_column_expr->execute_column(context,
block, tmp_column));
+ RETURN_IF_ERROR(
+ _virtual_column_expr->execute_column(context, block,
count, tmp_column));
result_column = std::move(tmp_column);
VLOG_DEBUG << fmt::format(
@@ -159,6 +160,7 @@ Status VirtualSlotRef::execute_column(VExprContext*
context, const Block* block,
return Status::OK();
}
}
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/virtual_slot_ref.h
b/be/src/vec/exprs/virtual_slot_ref.h
index 0de2772486b..eaf2bce9d13 100644
--- a/be/src/vec/exprs/virtual_slot_ref.h
+++ b/be/src/vec/exprs/virtual_slot_ref.h
@@ -31,7 +31,7 @@ public:
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
FunctionContext::FunctionStateScope scope) override;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
const std::string& expr_name() const override;
std::string expr_label() override;
diff --git a/be/src/vec/exprs/vlambda_function_call_expr.h
b/be/src/vec/exprs/vlambda_function_call_expr.h
index 4699b35d750..1f64d3aaea6 100644
--- a/be/src/vec/exprs/vlambda_function_call_expr.h
+++ b/be/src/vec/exprs/vlambda_function_call_expr.h
@@ -63,10 +63,11 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
DCHECK(_open_finished || _getting_const_col);
- return _lambda_function->execute(context, block, result_column,
_data_type, _children);
+ return _lambda_function->execute(context, block, count, result_column,
_data_type,
+ _children);
}
std::string debug_string() const override {
diff --git a/be/src/vec/exprs/vlambda_function_expr.h
b/be/src/vec/exprs/vlambda_function_expr.h
index 858b8a6ab52..b9455d343bd 100644
--- a/be/src/vec/exprs/vlambda_function_expr.h
+++ b/be/src/vec/exprs/vlambda_function_expr.h
@@ -42,10 +42,10 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
DCHECK(_open_finished || _getting_const_col);
- return get_child(0)->execute_column(context, block, result_column);
+ return get_child(0)->execute_column(context, block, count,
result_column);
}
DataTypePtr execute_type(const Block* block) const override {
diff --git a/be/src/vec/exprs/vliteral.cpp b/be/src/vec/exprs/vliteral.cpp
index a57fbfda6a7..92547bcf706 100644
--- a/be/src/vec/exprs/vliteral.cpp
+++ b/be/src/vec/exprs/vliteral.cpp
@@ -49,10 +49,10 @@ Status VLiteral::prepare(RuntimeState* state, const
RowDescriptor& desc, VExprCo
return Status::OK();
}
-Status VLiteral::execute_column(VExprContext* context, const Block* block,
+Status VLiteral::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
- size_t row_size = std::max(block->rows(), _column_ptr->size());
- result_column = _column_ptr->clone_resized(row_size);
+ result_column = _column_ptr->clone_resized(count);
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vliteral.h b/be/src/vec/exprs/vliteral.h
index be2490e35ca..b11207467ec 100644
--- a/be/src/vec/exprs/vliteral.h
+++ b/be/src/vec/exprs/vliteral.h
@@ -48,7 +48,7 @@ public:
#endif
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
const std::string& expr_name() const override { return _expr_name; }
diff --git a/be/src/vec/exprs/vmatch_predicate.cpp
b/be/src/vec/exprs/vmatch_predicate.cpp
index 83698f1e43d..a923a5bcc40 100644
--- a/be/src/vec/exprs/vmatch_predicate.cpp
+++ b/be/src/vec/exprs/vmatch_predicate.cpp
@@ -135,7 +135,7 @@ Status
VMatchPredicate::evaluate_inverted_index(VExprContext* context, uint32_t
return _evaluate_inverted_index(context, _function, segment_num_rows);
}
-Status VMatchPredicate::execute_column(VExprContext* context, const Block*
block,
+Status VMatchPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
ColumnPtr& result_column) const {
DCHECK(_open_finished || _getting_const_col);
if (fast_execute(context, result_column)) {
@@ -164,7 +164,7 @@ Status VMatchPredicate::execute_column(VExprContext*
context, const Block* block
Block temp_block;
for (int i = 0; i < _children.size(); ++i) {
ColumnPtr arg_column;
- RETURN_IF_ERROR(_children[i]->execute_column(context, block,
arg_column));
+ RETURN_IF_ERROR(_children[i]->execute_column(context, block, count,
arg_column));
auto arg_type = _children[i]->execute_type(block);
temp_block.insert({arg_column, arg_type, _children[i]->expr_name()});
arguments[i] = i;
@@ -174,8 +174,9 @@ Status VMatchPredicate::execute_column(VExprContext*
context, const Block* block
temp_block.insert({nullptr, _data_type, _expr_name});
RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index),
temp_block,
- arguments, num_columns_without_result,
block->rows()));
+ arguments, num_columns_without_result,
temp_block.rows()));
result_column =
temp_block.get_by_position(num_columns_without_result).column;
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vmatch_predicate.h
b/be/src/vec/exprs/vmatch_predicate.h
index 78dc06728c3..bef42c6205d 100644
--- a/be/src/vec/exprs/vmatch_predicate.h
+++ b/be/src/vec/exprs/vmatch_predicate.h
@@ -49,7 +49,7 @@ class VMatchPredicate final : public VExpr {
public:
VMatchPredicate(const TExprNode& node);
~VMatchPredicate() override;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
diff --git a/be/src/vec/exprs/vruntimefilter_wrapper.cpp
b/be/src/vec/exprs/vruntimefilter_wrapper.cpp
index 8e915ffff67..7e65fc953b2 100644
--- a/be/src/vec/exprs/vruntimefilter_wrapper.cpp
+++ b/be/src/vec/exprs/vruntimefilter_wrapper.cpp
@@ -88,13 +88,13 @@ void VRuntimeFilterWrapper::close(VExprContext* context,
}
Status VRuntimeFilterWrapper::execute_column(VExprContext* context, const
Block* block,
- ColumnPtr& result_column) const {
+ size_t count, ColumnPtr&
result_column) const {
DCHECK(_open_finished || _getting_const_col);
if (_judge_counter.fetch_sub(1) == 0) {
reset_judge_selectivity();
}
if (_always_true) {
- size_t size = block->rows();
+ size_t size = count;
result_column = create_always_true_column(size,
_data_type->is_nullable());
COUNTER_UPDATE(_always_true_filter_rows, size);
return Status::OK();
@@ -104,7 +104,8 @@ Status VRuntimeFilterWrapper::execute_column(VExprContext*
context, const Block*
}
ColumnPtr arg_column = nullptr;
- RETURN_IF_ERROR(_impl->execute_runtime_filter(context, block,
result_column, &arg_column));
+ RETURN_IF_ERROR(
+ _impl->execute_runtime_filter(context, block, count,
result_column, &arg_column));
if (_getting_const_col) {
_impl->set_getting_const_col(false);
}
diff --git a/be/src/vec/exprs/vruntimefilter_wrapper.h
b/be/src/vec/exprs/vruntimefilter_wrapper.h
index 3535898915b..64ab79121d3 100644
--- a/be/src/vec/exprs/vruntimefilter_wrapper.h
+++ b/be/src/vec/exprs/vruntimefilter_wrapper.h
@@ -53,7 +53,7 @@ public:
VRuntimeFilterWrapper(const TExprNode& node, VExprSPtr impl, double
ignore_thredhold,
bool null_aware, int filter_id);
~VRuntimeFilterWrapper() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
diff --git a/be/src/vec/exprs/vsearch.cpp b/be/src/vec/exprs/vsearch.cpp
index 0bba97626f6..7736cd67c8d 100644
--- a/be/src/vec/exprs/vsearch.cpp
+++ b/be/src/vec/exprs/vsearch.cpp
@@ -125,7 +125,7 @@ const std::string& VSearchExpr::expr_name() const {
return name;
}
-Status VSearchExpr::execute_column(VExprContext* context, const Block* block,
+Status VSearchExpr::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
if (fast_execute(context, result_column)) {
return Status::OK();
diff --git a/be/src/vec/exprs/vsearch.h b/be/src/vec/exprs/vsearch.h
index 602524fe300..d5a558ce6a8 100644
--- a/be/src/vec/exprs/vsearch.h
+++ b/be/src/vec/exprs/vsearch.h
@@ -26,7 +26,7 @@ class VSearchExpr : public VExpr {
public:
VSearchExpr(const TExprNode& node);
~VSearchExpr() override = default;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
const std::string& expr_name() const override;
Status evaluate_inverted_index(VExprContext* context, uint32_t
segment_num_rows) override;
diff --git a/be/src/vec/exprs/vslot_ref.cpp b/be/src/vec/exprs/vslot_ref.cpp
index 492504dd884..2435b114e1e 100644
--- a/be/src/vec/exprs/vslot_ref.cpp
+++ b/be/src/vec/exprs/vslot_ref.cpp
@@ -86,7 +86,7 @@ Status VSlotRef::execute(VExprContext* context, Block* block,
int* result_column
return Status::OK();
}
-Status VSlotRef::execute_column(VExprContext* context, const Block* block,
+Status VSlotRef::execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const {
if (_column_id >= 0 && _column_id >= block->columns()) {
return Status::Error<ErrorCode::INTERNAL_ERROR>(
@@ -94,6 +94,7 @@ Status VSlotRef::execute_column(VExprContext* context, const
Block* block,
_column_id, block->dump_structure());
}
result_column = block->get_by_position(_column_id).column;
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/src/vec/exprs/vslot_ref.h b/be/src/vec/exprs/vslot_ref.h
index 3f991eebc6a..ff7e3812d76 100644
--- a/be/src/vec/exprs/vslot_ref.h
+++ b/be/src/vec/exprs/vslot_ref.h
@@ -47,7 +47,7 @@ public:
Status open(RuntimeState* state, VExprContext* context,
FunctionContext::FunctionStateScope scope) override;
Status execute(VExprContext* context, Block* block, int* result_column_id)
const override;
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
DataTypePtr execute_type(const Block* block) const override;
diff --git a/be/src/vec/exprs/vtopn_pred.h b/be/src/vec/exprs/vtopn_pred.h
index 06bc2fcc57b..33c804b4f39 100644
--- a/be/src/vec/exprs/vtopn_pred.h
+++ b/be/src/vec/exprs/vtopn_pred.h
@@ -81,10 +81,10 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
if (!_predicate->has_value()) {
- result_column = create_always_true_column(block->rows(),
_data_type->is_nullable());
+ result_column = create_always_true_column(count,
_data_type->is_nullable());
return Status::OK();
}
@@ -92,7 +92,7 @@ public:
// slot
ColumnPtr slot_column;
- RETURN_IF_ERROR(_children[0]->execute_column(context, block,
slot_column));
+ RETURN_IF_ERROR(_children[0]->execute_column(context, block, count,
slot_column));
auto slot_type = _children[0]->execute_type(block);
temp_block.insert({slot_column, slot_type, _children[0]->expr_name()});
int slot_id = 0;
@@ -102,7 +102,7 @@ public:
auto column_ptr = _children[0]->data_type()->create_column_const(1,
field);
int topn_value_id = VExpr::insert_param(&temp_block,
{column_ptr,
_children[0]->data_type(), _expr_name},
- std::max(block->rows(),
column_ptr->size()));
+ std::max(count,
column_ptr->size()));
// if error(slot_id == -1), will return.
ColumnNumbers arguments = {static_cast<uint32_t>(slot_id),
@@ -113,12 +113,13 @@ public:
temp_block.insert({nullptr, _data_type, _expr_name});
RETURN_IF_ERROR(_function->execute(nullptr, temp_block, arguments,
- num_columns_without_result,
block->rows()));
+ num_columns_without_result,
temp_block.rows()));
result_column =
std::move(temp_block.get_by_position(num_columns_without_result).column);
if (is_nullable() && _predicate->nulls_first()) {
// null values are always not filtered
change_null_to_true(result_column->assume_mutable());
}
+ DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
diff --git a/be/test/exprs/mock_vexpr.h b/be/test/exprs/mock_vexpr.h
index 09f5daf4963..1b3083e24f3 100644
--- a/be/test/exprs/mock_vexpr.h
+++ b/be/test/exprs/mock_vexpr.h
@@ -31,8 +31,8 @@ public:
MOCK_CONST_METHOD0(expr_name, const std::string&());
MOCK_CONST_METHOD3(execute, Status(VExprContext* context,
vectorized::Block* block,
int* result_column_id));
- MOCK_CONST_METHOD3(execute_column, Status(VExprContext* context, const
vectorized::Block* block,
- ColumnPtr& result_column));
+ MOCK_CONST_METHOD4(execute_column, Status(VExprContext* context, const
vectorized::Block* block,
+ size_t count, ColumnPtr&
result_column));
}; // class MockVExpr
} // namespace vectorized
diff --git a/be/test/exprs/virtual_slot_ref_test.cpp
b/be/test/exprs/virtual_slot_ref_test.cpp
index 633042718f5..9027ee97f19 100644
--- a/be/test/exprs/virtual_slot_ref_test.cpp
+++ b/be/test/exprs/virtual_slot_ref_test.cpp
@@ -170,7 +170,7 @@ TEST_F(VirtualSlotRefTest,
EqualsFunction_WithDifferentTypes) {
Status execute(VExprContext* context, Block* block, int*
result_column_id) const override {
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const override {
return Status::OK();
}
@@ -291,7 +291,7 @@ TEST_F(VirtualSlotRefTest, EqualsFunction_TestAllBranches) {
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const override {
return Status::OK();
}
@@ -316,7 +316,7 @@ TEST_F(VirtualSlotRefTest, EqualsFunction_TestAllBranches) {
Status execute(VExprContext* context, Block* block, int*
result_column_id) const override {
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block,
size_t count,
ColumnPtr& result_column) const override {
return Status::OK();
}
diff --git a/be/test/olap/collection_statistics_test.cpp
b/be/test/olap/collection_statistics_test.cpp
index 87c7e9d5c05..7988f842161 100644
--- a/be/test/olap/collection_statistics_test.cpp
+++ b/be/test/olap/collection_statistics_test.cpp
@@ -53,7 +53,7 @@ public:
}
Status execute_column(vectorized::VExprContext* context, const
vectorized::Block* block,
- vectorized::ColumnPtr& result_column) const override
{
+ size_t count, vectorized::ColumnPtr& result_column)
const override {
return Status::OK();
}
diff --git a/be/test/testutil/mock/mock_literal_expr.cpp
b/be/test/testutil/mock/mock_literal_expr.cpp
index 656511d9667..8e17dfd5dfe 100644
--- a/be/test/testutil/mock/mock_literal_expr.cpp
+++ b/be/test/testutil/mock/mock_literal_expr.cpp
@@ -29,6 +29,7 @@ TEST(MockLiteralTest, test) {
{
auto ctxs = MockLiteral::create<DataTypeInt64>({1, 2, 3, 4});
Block block;
+
block.insert(ColumnHelper::create_column_with_name<DataTypeInt64>({0}));
for (auto& ctx : ctxs) {
int result_column_id = -1;
EXPECT_TRUE(ctx->execute(&block, &result_column_id));
@@ -38,6 +39,7 @@ TEST(MockLiteralTest, test) {
EXPECT_TRUE(ColumnHelper::block_equal(
block, Block {
+
ColumnHelper::create_column_with_name<DataTypeInt64>({0}),
ColumnHelper::create_column_with_name<DataTypeInt64>({1}),
ColumnHelper::create_column_with_name<DataTypeInt64>({2}),
ColumnHelper::create_column_with_name<DataTypeInt64>({3}),
@@ -50,6 +52,7 @@ TEST(MockLiteralTest, test_const) {
{
auto ctxs = MockLiteral::create_const<DataTypeInt64>({1, 2, 3, 4}, 5);
Block block;
+ block.insert(ColumnHelper::create_column_with_name<DataTypeInt64>({0,
0, 0, 0, 0}));
for (auto& ctx : ctxs) {
int result_column_id = -1;
EXPECT_TRUE(ctx->execute(&block, &result_column_id));
@@ -62,6 +65,7 @@ TEST(MockLiteralTest, test_const) {
EXPECT_TRUE(ColumnHelper::block_equal(
block,
Block {
+
ColumnHelper::create_column_with_name<DataTypeInt64>({0, 0, 0, 0, 0}),
ColumnHelper::create_column_with_name<DataTypeInt64>({1, 1, 1, 1, 1}),
ColumnHelper::create_column_with_name<DataTypeInt64>({2, 2, 2, 2, 2}),
ColumnHelper::create_column_with_name<DataTypeInt64>({3, 3, 3, 3, 3}),
diff --git a/be/test/vec/exprs/try_cast_expr_test.cpp
b/be/test/vec/exprs/try_cast_expr_test.cpp
index 75c2feb64b2..eac351d29d9 100644
--- a/be/test/vec/exprs/try_cast_expr_test.cpp
+++ b/be/test/vec/exprs/try_cast_expr_test.cpp
@@ -21,6 +21,7 @@
#include "runtime/primitive_type.h"
#include "udf/udf.h"
+#include "vec/columns/column_nothing.h"
#include "vec/columns/column_nullable.h"
#include "vec/core/field.h"
#include "vec/core/types.h"
@@ -140,7 +141,7 @@ public:
return Status::OK();
}
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
auto int_type = std::make_shared<DataTypeInt32>();
auto int_column = int_type->create_column();
@@ -221,6 +222,8 @@ TEST_F(TryCastExprTest, row_exec1) {
Block block;
int result_column_id = -1;
try_cast_expr._original_cast_return_is_nullable = false;
+ block.insert(ColumnWithTypeAndName {ColumnNothing::create(3),
std::make_shared<DataTypeInt32>(),
+ "mock_input_column"});
auto st = try_cast_expr.execute(context.get(), &block, &result_column_id);
EXPECT_TRUE(st.ok()) << st.msg();
@@ -240,6 +243,8 @@ TEST_F(TryCastExprTest, row_exec2) {
Block block;
int result_column_id = -1;
try_cast_expr._original_cast_return_is_nullable = true;
+ block.insert(ColumnWithTypeAndName {ColumnNothing::create(3),
std::make_shared<DataTypeInt32>(),
+ "mock_input_column"});
auto st = try_cast_expr.execute(context.get(), &block, &result_column_id);
EXPECT_TRUE(st.ok()) << st.msg();
@@ -259,6 +264,8 @@ TEST_F(TryCastExprTest, row_exec3) {
Block block;
int result_column_id = -1;
try_cast_expr._original_cast_return_is_nullable = true;
+ block.insert(ColumnWithTypeAndName {ColumnNothing::create(3),
std::make_shared<DataTypeInt32>(),
+ "mock_input_column"});
auto st = try_cast_expr.execute(context.get(), &block, &result_column_id);
EXPECT_FALSE(st.ok()) << st.msg();
}
diff --git a/be/test/vec/exprs/vsearch_expr_test.cpp
b/be/test/vec/exprs/vsearch_expr_test.cpp
index acd3def2f69..b3763de9025 100644
--- a/be/test/vec/exprs/vsearch_expr_test.cpp
+++ b/be/test/vec/exprs/vsearch_expr_test.cpp
@@ -70,7 +70,7 @@ public:
}
Status execute(VExprContext*, Block*, int*) const override { return
Status::OK(); }
- Status execute_column(VExprContext* context, const Block* block,
+ Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
return Status::OK();
}
@@ -846,14 +846,14 @@ TEST_F(VSearchExprTest, TestSingleChildBooleanClause) {
TEST_F(VSearchExprTest, TestExecuteWithNullBlock) {
auto vsearch_expr = VSearchExpr::create_shared(test_node);
- int result_column_id = -1;
-
// Create a basic VExprContext without inverted index context
auto dummy_expr = VSearchExpr::create_shared(test_node);
VExprContext context(dummy_expr);
// Test with null block (should not crash)
- auto status = vsearch_expr->execute(&context, nullptr, &result_column_id);
+
+ ColumnPtr result_column;
+ auto status = vsearch_expr->execute_column(&context, nullptr, 0,
result_column);
EXPECT_FALSE(status.ok());
EXPECT_TRUE(status.code() == ErrorCode::INTERNAL_ERROR);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
