You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by li...@apache.org on 2022/05/13 04:42:48 UTC
[incubator-doris] branch master updated: [feature-wip](array-type) array_contains support more nested data types (#9170)
This is an automated email from the ASF dual-hosted git repository.
lihaopeng pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-doris.git
The following commit(s) were added to refs/heads/master by this push:
new 650e3a6ba0 [feature-wip](array-type) array_contains support more nested data types (#9170)
650e3a6ba0 is described below
commit 650e3a6ba00595bc99fd4cb5b18ab7ed67610dff
Author: camby <10...@qq.com>
AuthorDate: Fri May 13 12:42:40 2022 +0800
[feature-wip](array-type) array_contains support more nested data types (#9170)
Co-authored-by: cambyzju <zh...@baidu.com>
---
be/src/vec/columns/column.h | 4 +-
be/src/vec/columns/column_decimal.h | 1 +
be/src/vec/columns/column_nullable.h | 4 +-
be/src/vec/data_types/data_type_date.cpp | 6 +
be/src/vec/data_types/data_type_date.h | 2 +
be/src/vec/data_types/data_type_date_time.cpp | 6 +
be/src/vec/data_types/data_type_date_time.h | 2 +
be/src/vec/exec/vunion_node.cpp | 3 +-
.../vec/functions/array/function_array_element.h | 50 +++--
be/src/vec/functions/array/function_array_index.h | 239 ++++++++++++---------
.../vec/function/function_array_element_test.cpp | 86 ++++++++
be/test/vec/function/function_array_index_test.cpp | 127 +++++++++++
be/test/vec/function/function_test_util.cpp | 9 +-
be/test/vec/function/function_test_util.h | 14 +-
gensrc/script/doris_builtins_functions.py | 100 ++++-----
15 files changed, 467 insertions(+), 186 deletions(-)
diff --git a/be/src/vec/columns/column.h b/be/src/vec/columns/column.h
index 1dd74261d8..ea8b952f8c 100644
--- a/be/src/vec/columns/column.h
+++ b/be/src/vec/columns/column.h
@@ -464,8 +464,8 @@ public:
// only used in ColumnNullable replace_column_data
virtual void replace_column_data_default(size_t self_row = 0) = 0;
- virtual bool is_date_type() { return is_date; }
- virtual bool is_datetime_type() { return is_date_time; }
+ virtual bool is_date_type() const { return is_date; }
+ virtual bool is_datetime_type() const { return is_date_time; }
virtual void set_date_type() { is_date = true; }
virtual void set_datetime_type() { is_date_time = true; }
diff --git a/be/src/vec/columns/column_decimal.h b/be/src/vec/columns/column_decimal.h
index 4f3a2bc3d4..98c2d05ef4 100644
--- a/be/src/vec/columns/column_decimal.h
+++ b/be/src/vec/columns/column_decimal.h
@@ -71,6 +71,7 @@ private:
friend class COWHelper<ColumnVectorHelper, Self>;
public:
+ using value_type = T;
using Container = DecimalPaddedPODArray<T>;
private:
diff --git a/be/src/vec/columns/column_nullable.h b/be/src/vec/columns/column_nullable.h
index 482b9a5bfe..410ed8b42a 100644
--- a/be/src/vec/columns/column_nullable.h
+++ b/be/src/vec/columns/column_nullable.h
@@ -163,8 +163,8 @@ public:
return false;
}
- bool is_date_type() override { return get_nested_column().is_date_type(); }
- bool is_datetime_type() override { return get_nested_column().is_datetime_type(); }
+ bool is_date_type() const override { return get_nested_column().is_date_type(); }
+ bool is_datetime_type() const override { return get_nested_column().is_datetime_type(); }
void set_date_type() override { get_nested_column().set_date_type(); }
void set_datetime_type() override { get_nested_column().set_datetime_type(); }
diff --git a/be/src/vec/data_types/data_type_date.cpp b/be/src/vec/data_types/data_type_date.cpp
index a23dde0725..2508570a53 100644
--- a/be/src/vec/data_types/data_type_date.cpp
+++ b/be/src/vec/data_types/data_type_date.cpp
@@ -65,4 +65,10 @@ void DataTypeDate::cast_to_date(Int64& x) {
x = binary_cast<VecDateTimeValue, Int64>(value);
}
+MutableColumnPtr DataTypeDate::create_column() const {
+ auto col = DataTypeNumberBase<Int64>::create_column();
+ col->set_date_type();
+ return col;
+}
+
} // namespace doris::vectorized
diff --git a/be/src/vec/data_types/data_type_date.h b/be/src/vec/data_types/data_type_date.h
index 160b7d4a0c..06f8ff0d0e 100644
--- a/be/src/vec/data_types/data_type_date.h
+++ b/be/src/vec/data_types/data_type_date.h
@@ -38,6 +38,8 @@ public:
void to_string(const IColumn& column, size_t row_num, BufferWritable& ostr) const override;
static void cast_to_date(Int64& x);
+
+ MutableColumnPtr create_column() const override;
};
} // namespace doris::vectorized
diff --git a/be/src/vec/data_types/data_type_date_time.cpp b/be/src/vec/data_types/data_type_date_time.cpp
index 5cb568b3ce..5271091f87 100644
--- a/be/src/vec/data_types/data_type_date_time.cpp
+++ b/be/src/vec/data_types/data_type_date_time.cpp
@@ -88,4 +88,10 @@ void DataTypeDateTime::cast_to_date_time(Int64& x) {
x = binary_cast<doris::vectorized::VecDateTimeValue, Int64>(value);
}
+MutableColumnPtr DataTypeDateTime::create_column() const {
+ auto col = DataTypeNumberBase<Int64>::create_column();
+ col->set_datetime_type();
+ return col;
+}
+
} // namespace doris::vectorized
diff --git a/be/src/vec/data_types/data_type_date_time.h b/be/src/vec/data_types/data_type_date_time.h
index a429e2d0f2..adf41bfc8b 100644
--- a/be/src/vec/data_types/data_type_date_time.h
+++ b/be/src/vec/data_types/data_type_date_time.h
@@ -65,6 +65,8 @@ public:
void to_string(const IColumn& column, size_t row_num, BufferWritable& ostr) const override;
static void cast_to_date_time(Int64& x);
+
+ MutableColumnPtr create_column() const override;
};
template <typename DataType>
diff --git a/be/src/vec/exec/vunion_node.cpp b/be/src/vec/exec/vunion_node.cpp
index cb410c3794..f1c3002218 100644
--- a/be/src/vec/exec/vunion_node.cpp
+++ b/be/src/vec/exec/vunion_node.cpp
@@ -189,7 +189,8 @@ Status VUnionNode::get_next_const(RuntimeState* state, Block* block) {
int const_expr_lists_size = _const_expr_lists[_const_expr_list_idx].size();
std::vector<int> result_list(const_expr_lists_size);
for (size_t i = 0; i < const_expr_lists_size; ++i) {
- _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(&tmp_block,
+ &result_list[i]));
}
tmp_block.erase_not_in(result_list);
mblock.merge(tmp_block);
diff --git a/be/src/vec/functions/array/function_array_element.h b/be/src/vec/functions/array/function_array_element.h
index eae3375bca..a37913915b 100644
--- a/be/src/vec/functions/array/function_array_element.h
+++ b/be/src/vec/functions/array/function_array_element.h
@@ -90,9 +90,11 @@ private:
ColumnPtr _execute_number(const ColumnArray::Offsets& offsets, const IColumn& nested_column,
const UInt8* arr_null_map, const IColumn& indices,
const UInt8* nested_null_map, UInt8* dst_null_map) {
- const auto& nested_data = check_and_get_column<ColumnType>(nested_column)->get_data();
- auto dst_column = ColumnType::create(offsets.size());
- auto& dst_data = dst_column->get_data();
+ const auto& nested_data = reinterpret_cast<const ColumnType&>(nested_column).get_data();
+
+ auto dst_column = nested_column.clone_empty();
+ auto& dst_data = reinterpret_cast<ColumnType&>(*dst_column).get_data();
+ dst_data.resize(offsets.size());
// process
for (size_t row = 0; row < offsets.size(); ++row) {
@@ -129,8 +131,10 @@ private:
ColumnPtr _execute_string(const ColumnArray::Offsets& offsets, const IColumn& nested_column,
const UInt8* arr_null_map, const IColumn& indices,
const UInt8* nested_null_map, UInt8* dst_null_map) {
- const auto& src_str_offs = check_and_get_column<ColumnString>(nested_column)->get_offsets();
- const auto& src_str_chars = check_and_get_column<ColumnString>(nested_column)->get_chars();
+ const auto& src_str_offs =
+ reinterpret_cast<const ColumnString&>(nested_column).get_offsets();
+ const auto& src_str_chars =
+ reinterpret_cast<const ColumnString&>(nested_column).get_chars();
// prepare return data
auto dst_column = ColumnString::create();
@@ -181,23 +185,33 @@ private:
const DataTypePtr& result_type, size_t input_rows_count,
const UInt8* src_null_map, UInt8* dst_null_map) {
// check array nested column type and get data
- auto array_column = check_and_get_column<ColumnArray>(*arguments[0].column);
- DCHECK(array_column != nullptr);
- const auto& offsets = array_column->get_offsets();
+ auto left_column = arguments[0].column->convert_to_full_column_if_const();
+ const auto& array_column = reinterpret_cast<const ColumnArray&>(*left_column);
+ const auto& offsets = array_column.get_offsets();
DCHECK(offsets.size() == input_rows_count);
const UInt8* nested_null_map = nullptr;
ColumnPtr nested_column = nullptr;
- if (is_column_nullable(array_column->get_data())) {
+ if (is_column_nullable(array_column.get_data())) {
const auto& nested_null_column =
- check_and_get_column<ColumnNullable>(array_column->get_data());
- nested_null_map = nested_null_column->get_null_map_column().get_data().data();
- nested_column = nested_null_column->get_nested_column_ptr();
+ reinterpret_cast<const ColumnNullable&>(array_column.get_data());
+ nested_null_map = nested_null_column.get_null_map_column().get_data().data();
+ nested_column = nested_null_column.get_nested_column_ptr();
} else {
- nested_column = array_column->get_data_ptr();
+ nested_column = array_column.get_data_ptr();
}
ColumnPtr res = nullptr;
- if (check_column<ColumnInt8>(*nested_column)) {
+ if (nested_column->is_date_type()) {
+ res = _execute_number<ColumnDate>(offsets, *nested_column, src_null_map,
+ *arguments[1].column, nested_null_map, dst_null_map);
+ } else if (nested_column->is_datetime_type()) {
+ res = _execute_number<ColumnDateTime>(offsets, *nested_column, src_null_map,
+ *arguments[1].column, nested_null_map,
+ dst_null_map);
+ } else if (check_column<ColumnUInt8>(*nested_column)) {
+ res = _execute_number<ColumnUInt8>(offsets, *nested_column, src_null_map,
+ *arguments[1].column, nested_null_map, dst_null_map);
+ } else if (check_column<ColumnInt8>(*nested_column)) {
res = _execute_number<ColumnInt8>(offsets, *nested_column, src_null_map,
*arguments[1].column, nested_null_map, dst_null_map);
} else if (check_column<ColumnInt16>(*nested_column)) {
@@ -209,6 +223,10 @@ private:
} else if (check_column<ColumnInt64>(*nested_column)) {
res = _execute_number<ColumnInt64>(offsets, *nested_column, src_null_map,
*arguments[1].column, nested_null_map, dst_null_map);
+ } else if (check_column<ColumnInt128>(*nested_column)) {
+ res = _execute_number<ColumnInt128>(offsets, *nested_column, src_null_map,
+ *arguments[1].column, nested_null_map,
+ dst_null_map);
} else if (check_column<ColumnFloat32>(*nested_column)) {
res = _execute_number<ColumnFloat32>(offsets, *nested_column, src_null_map,
*arguments[1].column, nested_null_map,
@@ -217,6 +235,10 @@ private:
res = _execute_number<ColumnFloat64>(offsets, *nested_column, src_null_map,
*arguments[1].column, nested_null_map,
dst_null_map);
+ } else if (check_column<ColumnDecimal128>(*nested_column)) {
+ res = _execute_number<ColumnDecimal128>(offsets, *nested_column, src_null_map,
+ *arguments[1].column, nested_null_map,
+ dst_null_map);
} else if (check_column<ColumnString>(*nested_column)) {
res = _execute_string(offsets, *nested_column, src_null_map, *arguments[1].column,
nested_null_map, dst_null_map);
diff --git a/be/src/vec/functions/array/function_array_index.h b/be/src/vec/functions/array/function_array_index.h
index 435fa7a1d5..dd46373ce5 100644
--- a/be/src/vec/functions/array/function_array_index.h
+++ b/be/src/vec/functions/array/function_array_index.h
@@ -67,54 +67,25 @@ public:
}
private:
- static bool _execute_string(Block& block, const ColumnNumbers& arguments, size_t result,
- size_t input_rows_count) {
+ ColumnPtr _execute_string(const ColumnArray::Offsets& offsets, const UInt8* nested_null_map,
+ const IColumn& nested_column, const IColumn& right_column) {
// check array nested column type and get data
- auto array_column =
- check_and_get_column<ColumnArray>(*block.get_by_position(arguments[0]).column);
- DCHECK(array_column != nullptr);
- const ColumnString* nested_column = nullptr;
- const UInt8* nested_null_map = nullptr;
- auto nested_null_column = check_and_get_column<ColumnNullable>(array_column->get_data());
- if (nested_null_column) {
- nested_null_map = nested_null_column->get_null_map_column().get_data().data();
- nested_column =
- check_and_get_column<ColumnString>(nested_null_column->get_nested_column());
- } else {
- nested_column = check_and_get_column<ColumnString>(array_column->get_data());
- }
- if (!nested_column) {
- return false;
- }
- const auto& arr_offs = array_column->get_offsets();
- const auto& str_offs = nested_column->get_offsets();
- const auto& str_chars = nested_column->get_chars();
-
- // check right column type
- auto ptr = block.get_by_position(arguments[1]).column;
- if (is_column_const(*ptr)) {
- ptr = check_and_get_column<ColumnConst>(ptr)->get_data_column_ptr();
- }
- if (!check_and_get_column<ColumnString>(*ptr)) {
- return false;
- }
+ const auto& str_offs = reinterpret_cast<const ColumnString&>(nested_column).get_offsets();
+ const auto& str_chars = reinterpret_cast<const ColumnString&>(nested_column).get_chars();
- // expand const column and get data
- auto right_column = check_and_get_column<ColumnString>(
- *block.get_by_position(arguments[1]).column->convert_to_full_column_if_const());
- const auto& right_offs = right_column->get_offsets();
- const auto& right_chars = right_column->get_chars();
+ // check right column type and get data
+ const auto& right_offs = reinterpret_cast<const ColumnString&>(right_column).get_offsets();
+ const auto& right_chars = reinterpret_cast<const ColumnString&>(right_column).get_chars();
// prepare return data
- auto dst = ColumnVector<ResultType>::create();
+ auto dst = ColumnVector<ResultType>::create(offsets.size());
auto& dst_data = dst->get_data();
- dst_data.resize(input_rows_count);
// process
- for (size_t row = 0; row < input_rows_count; ++row) {
+ for (size_t row = 0; row < offsets.size(); ++row) {
ResultType res = 0;
- size_t off = arr_offs[row - 1];
- size_t len = arr_offs[row] - off;
+ size_t off = offsets[row - 1];
+ size_t len = offsets[row] - off;
size_t right_off = right_offs[row - 1];
size_t right_len = right_offs[row] - right_off;
@@ -135,69 +106,25 @@ private:
}
dst_data[row] = res;
}
- block.replace_by_position(result, std::move(dst));
- return true;
+ return dst;
}
-#define NUMBER_TPL_PACK Int8, Int16, Int32, Int64, Float32, Float64
- template <typename... Number>
- static bool _execute_number(Block& block, const ColumnNumbers& arguments, size_t result,
- size_t input_rows_count) {
- return (_execute_number_expanded<Number, Number...>(block, arguments, result,
- input_rows_count) ||
- ...);
- }
- template <typename A, typename... Other>
- static bool _execute_number_expanded(Block& block, const ColumnNumbers& arguments,
- size_t result, size_t input_rows_count) {
- return (_execute_number_impl<A, Other>(block, arguments, result, input_rows_count) || ...);
- }
- template <typename LeftElementType, typename RightType>
- static bool _execute_number_impl(Block& block, const ColumnNumbers& arguments, size_t result,
- size_t input_rows_count) {
+ template <typename NestedColumnType, typename RightColumnType>
+ ColumnPtr _execute_number(const ColumnArray::Offsets& offsets, const UInt8* nested_null_map,
+ const IColumn& nested_column, const IColumn& right_column) {
// check array nested column type and get data
- auto array_column =
- check_and_get_column<ColumnArray>(*block.get_by_position(arguments[0]).column);
- DCHECK(array_column != nullptr);
- const ColumnVector<LeftElementType>* nested_column = nullptr;
- const UInt8* nested_null_map = nullptr;
- auto nested_null_column = check_and_get_column<ColumnNullable>(array_column->get_data());
- if (nested_null_column) {
- nested_null_map = nested_null_column->get_null_map_column().get_data().data();
- nested_column = check_and_get_column<ColumnVector<LeftElementType>>(
- nested_null_column->get_nested_column());
- } else {
- nested_column =
- check_and_get_column<ColumnVector<LeftElementType>>(array_column->get_data());
- }
- if (!nested_column) {
- return false;
- }
- const auto& offsets = array_column->get_offsets();
- const auto& nested_data = nested_column->get_data();
-
- // check right column type
- auto ptr = block.get_by_position(arguments[1]).column;
- if (is_column_const(*ptr)) {
- ptr = check_and_get_column<ColumnConst>(ptr)->get_data_column_ptr();
- }
- if (!check_and_get_column<ColumnVector<RightType>>(*ptr)) {
- return false;
- }
+ const auto& nested_data =
+ reinterpret_cast<const NestedColumnType&>(nested_column).get_data();
- // expand const column and get data
- auto right_column =
- block.get_by_position(arguments[1]).column->convert_to_full_column_if_const();
- const auto& right_data =
- check_and_get_column<ColumnVector<RightType>>(*right_column)->get_data();
+ // check right column type and get data
+ const auto& right_data = reinterpret_cast<const RightColumnType&>(right_column).get_data();
// prepare return data
- auto dst = ColumnVector<ResultType>::create();
+ auto dst = ColumnVector<ResultType>::create(offsets.size());
auto& dst_data = dst->get_data();
- dst_data.resize(input_rows_count);
// process
- for (size_t row = 0; row < input_rows_count; ++row) {
+ for (size_t row = 0; row < offsets.size(); ++row) {
ResultType res = 0;
size_t off = offsets[row - 1];
size_t len = offsets[row] - off;
@@ -213,24 +140,130 @@ private:
}
dst_data[row] = res;
}
- block.replace_by_position(result, std::move(dst));
- return true;
+ return dst;
+ }
+
+ template <typename NestedColumnType>
+ ColumnPtr _execute_number_expanded(const ColumnArray::Offsets& offsets,
+ const UInt8* nested_null_map, const IColumn& nested_column,
+ const IColumn& right_column) {
+ if (check_column<ColumnUInt8>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnUInt8>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnInt8>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnInt8>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnInt16>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnInt16>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnInt32>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnInt32>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnInt64>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnInt64>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnInt128>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnInt128>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnFloat32>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnFloat32>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnFloat64>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnFloat64>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (right_column.is_date_type()) {
+ return _execute_number<NestedColumnType, ColumnDate>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (right_column.is_datetime_type()) {
+ return _execute_number<NestedColumnType, ColumnDateTime>(offsets, nested_null_map,
+ nested_column, right_column);
+ } else if (check_column<ColumnDecimal128>(right_column)) {
+ return _execute_number<NestedColumnType, ColumnDecimal128>(offsets, nested_null_map,
+ nested_column, right_column);
+ }
+ return nullptr;
}
Status _execute_non_nullable(Block& block, const ColumnNumbers& arguments, size_t result,
size_t input_rows_count) {
- WhichDataType right_type(block.get_by_position(arguments[1]).type);
- if ((right_type.is_string() &&
- _execute_string(block, arguments, result, input_rows_count)) ||
- _execute_number<NUMBER_TPL_PACK>(block, arguments, result, input_rows_count)) {
+ // extract array offsets and nested data
+ auto left_column =
+ block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();
+ const auto& array_column = reinterpret_cast<const ColumnArray&>(*left_column);
+ const auto& offsets = array_column.get_offsets();
+ const UInt8* nested_null_map = nullptr;
+ ColumnPtr nested_column = nullptr;
+ if (array_column.get_data().is_nullable()) {
+ const auto& nested_null_column =
+ reinterpret_cast<const ColumnNullable&>(array_column.get_data());
+ nested_null_map = nested_null_column.get_null_map_column().get_data().data();
+ nested_column = nested_null_column.get_nested_column_ptr();
+ } else {
+ nested_column = array_column.get_data_ptr();
+ }
+
+ // get right column
+ auto right_column =
+ block.get_by_position(arguments[1]).column->convert_to_full_column_if_const();
+
+ // execute
+ auto left_element_type = remove_nullable(
+ assert_cast<const DataTypeArray&>(*block.get_by_position(arguments[0]).type)
+ .get_nested_type());
+ auto right_type = remove_nullable(block.get_by_position(arguments[1]).type);
+
+ ColumnPtr return_column = nullptr;
+ if (is_string(right_type) && is_string(left_element_type)) {
+ return_column =
+ _execute_string(offsets, nested_null_map, *nested_column, *right_column);
+ } else if (is_number(right_type) && is_number(left_element_type)) {
+ if (check_column<ColumnUInt8>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnUInt8>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnInt8>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnInt8>(offsets, nested_null_map,
+ *nested_column, *right_column);
+ } else if (check_column<ColumnInt16>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnInt16>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnInt32>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnInt32>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnInt64>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnInt64>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnInt128>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnInt128>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnFloat32>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnFloat32>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnFloat64>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnFloat64>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ } else if (check_column<ColumnDecimal128>(*nested_column)) {
+ return_column = _execute_number_expanded<ColumnDecimal128>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ }
+ } else if (is_date_or_datetime(right_type) && is_date_or_datetime(left_element_type)) {
+ if (nested_column->is_date_type()) {
+ return_column = _execute_number_expanded<ColumnDate>(offsets, nested_null_map,
+ *nested_column, *right_column);
+ } else if (nested_column->is_datetime_type()) {
+ return_column = _execute_number_expanded<ColumnDateTime>(
+ offsets, nested_null_map, *nested_column, *right_column);
+ }
+ }
+
+ if (return_column) {
+ block.replace_by_position(result, std::move(return_column));
return Status::OK();
}
return Status::RuntimeError(
- fmt::format("unsupported types for function {}({}, {})", get_name(),
- block.get_by_position(arguments[0]).type->get_name(),
+ fmt::format("execute failed or unsupported types for function {}({}, {})",
+ get_name(), block.get_by_position(arguments[0]).type->get_name(),
block.get_by_position(arguments[1]).type->get_name()));
}
-#undef NUMBER_TPL_PACK
};
} // namespace doris::vectorized
diff --git a/be/test/vec/function/function_array_element_test.cpp b/be/test/vec/function/function_array_element_test.cpp
index f36c33c38a..39d9c23cab 100644
--- a/be/test/vec/function/function_array_element_test.cpp
+++ b/be/test/vec/function/function_array_element_test.cpp
@@ -24,6 +24,7 @@
#include "runtime/tuple_row.h"
#include "util/url_coding.h"
#include "vec/core/field.h"
+#include "vec/data_types/data_type_decimal.h"
namespace doris::vectorized {
@@ -57,6 +58,91 @@ TEST(function_array_element_test, element_at) {
check_function<DataTypeInt8, true>(func_name, input_types, data_set);
}
+ // element_at(Array<Int128>, Int64)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Int128, TypeIndex::Int64};
+
+ Array vec = {Int128(1), Int128(2), Int128(3)};
+ DataSet data_set = {{{vec, Int64(0)}, Null()}, {{vec, Int64(1)}, Int128(1)},
+ {{vec, Int64(4)}, Null()}, {{vec, Int64(-1)}, Int128(3)},
+ {{vec, Int64(-3)}, Int128(1)}, {{vec, Int64(-4)}, Null()},
+ {{Null(), Int64(1)}, Null()}, {{empty_arr, Int64(0)}, Null()},
+ {{empty_arr, Int64(1)}, Null()}};
+
+ check_function<DataTypeInt128, true>(func_name, input_types, data_set);
+ }
+
+ // element_at(Array<Float64>, Int64)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Float64, TypeIndex::Int64};
+
+ Array vec = {double(1.11), double(2.22), double(3.33)};
+ DataSet data_set = {{{vec, Int64(0)}, Null()}, {{vec, Int64(1)}, double(1.11)},
+ {{vec, Int64(4)}, Null()}, {{vec, Int64(-1)}, double(3.33)},
+ {{vec, Int64(-3)}, double(1.11)}, {{vec, Int64(-4)}, Null()},
+ {{Null(), Int64(1)}, Null()}, {{empty_arr, Int64(0)}, Null()},
+ {{empty_arr, Int64(1)}, Null()}};
+
+ check_function<DataTypeFloat64, true>(func_name, input_types, data_set);
+ }
+
+ // element_at(Array<DateTime>, Int64)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::DateTime, TypeIndex::Int64};
+
+ Array vec = {str_to_data_time("2022-01-02 01:00:00"), str_to_data_time(""),
+ str_to_data_time("2022-07-08 03:00:00")};
+ DataSet data_set = {{{vec, Int64(0)}, Null()},
+ {{vec, Int64(1)}, str_to_data_time("2022-01-02 01:00:00")},
+ {{vec, Int64(4)}, Null()},
+ {{vec, Int64(-1)}, str_to_data_time("2022-07-08 03:00:00")},
+ {{vec, Int64(-2)}, str_to_data_time("")},
+ {{vec, Int64(-4)}, Null()},
+ {{Null(), Int64(1)}, Null()},
+ {{empty_arr, Int64(0)}, Null()},
+ {{empty_arr, Int64(1)}, Null()}};
+
+ check_function<DataTypeDateTime, true>(func_name, input_types, data_set);
+ }
+
+ // element_at(Array<Date>, Int64)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Date, TypeIndex::Int64};
+
+ Array vec = {str_to_data_time("2022-01-02"), str_to_data_time(""),
+ str_to_data_time("2022-07-08")};
+ DataSet data_set = {{{vec, Int64(0)}, Null()},
+ {{vec, Int64(1)}, str_to_data_time("2022-01-02")},
+ {{vec, Int64(4)}, Null()},
+ {{vec, Int64(-1)}, str_to_data_time("2022-07-08")},
+ {{vec, Int64(-2)}, str_to_data_time("")},
+ {{vec, Int64(-4)}, Null()},
+ {{Null(), Int64(1)}, Null()},
+ {{empty_arr, Int64(0)}, Null()},
+ {{empty_arr, Int64(1)}, Null()}};
+
+ check_function<DataTypeDate, true>(func_name, input_types, data_set);
+ }
+
+ // element_at(Array<Decimal128>, Int64)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Decimal128, TypeIndex::Int64};
+
+ Array vec = {ut_type::DECIMALFIELD(17014116.67), ut_type::DECIMALFIELD(-17014116.67),
+ ut_type::DECIMALFIELD(0.0)};
+ DataSet data_set = {{{vec, Int64(0)}, Null()},
+ {{vec, Int64(1)}, ut_type::DECIMAL(17014116.67)},
+ {{vec, Int64(4)}, Null()},
+ {{vec, Int64(-1)}, ut_type::DECIMAL(0.0)},
+ {{vec, Int64(-2)}, ut_type::DECIMAL(-17014116.67)},
+ {{vec, Int64(-4)}, Null()},
+ {{Null(), Int64(1)}, Null()},
+ {{empty_arr, Int64(0)}, Null()},
+ {{empty_arr, Int64(1)}, Null()}};
+
+ check_function<DataTypeDecimal<Decimal128>, true>(func_name, input_types, data_set);
+ }
+
// element_at(Array<String>, Int32)
{
InputTypeSet input_types = {TypeIndex::Array, TypeIndex::String, TypeIndex::Int32};
diff --git a/be/test/vec/function/function_array_index_test.cpp b/be/test/vec/function/function_array_index_test.cpp
index eb4c27f7f6..c1a0231a7d 100644
--- a/be/test/vec/function/function_array_index_test.cpp
+++ b/be/test/vec/function/function_array_index_test.cpp
@@ -70,6 +70,89 @@ TEST(function_array_index_test, array_contains) {
check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
}
+ // array_contains(Array<Int128>, Int128)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Int128, TypeIndex::Int128};
+
+ Array vec = {Int128(11111111111LL), Int128(22222LL), Int128(333LL)};
+ DataSet data_set = {{{vec, Int128(11111111111LL)}, UInt8(1)},
+ {{vec, Int128(4)}, UInt8(0)},
+ {{Null(), Int128(1)}, Null()},
+ {{empty_arr, Int128(1)}, UInt8(0)}};
+
+ check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
+ }
+
+ // array_contains(Array<Float32>, Float32)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Float32, TypeIndex::Float32};
+
+ Array vec = {float(1.2345), float(2.222), float(3.0)};
+ DataSet data_set = {{{vec, float(2.222)}, UInt8(1)},
+ {{vec, float(4)}, UInt8(0)},
+ {{Null(), float(1)}, Null()},
+ {{empty_arr, float(1)}, UInt8(0)}};
+
+ check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
+ }
+
+ // array_contains(Array<Float64>, Float64)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Float64, TypeIndex::Float64};
+
+ Array vec = {double(1.2345), double(2.222), double(3.0)};
+ DataSet data_set = {{{vec, double(2.222)}, UInt8(1)},
+ {{vec, double(4)}, UInt8(0)},
+ {{Null(), double(1)}, Null()},
+ {{empty_arr, double(1)}, UInt8(0)}};
+
+ check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
+ }
+
+ // array_contains(Array<Date>, Date)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Date, TypeIndex::Date};
+
+ Array vec = {str_to_data_time("2022-01-02", false), str_to_data_time("", false),
+ str_to_data_time("2022-07-08", false)};
+ DataSet data_set = {{{vec, std::string("2022-01-02")}, UInt8(1)},
+ {{vec, std::string("")}, UInt8(1)},
+ {{vec, std::string("2022-01-03")}, UInt8(0)},
+ {{Null(), std::string("2022-01-04")}, Null()},
+ {{empty_arr, std::string("2022-01-02")}, UInt8(0)}};
+
+ check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
+ }
+
+ // array_contains(Array<DateTime>, DateTime)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::DateTime, TypeIndex::DateTime};
+
+ Array vec = {str_to_data_time("2022-01-02 00:00:00"), str_to_data_time(""),
+ str_to_data_time("2022-07-08 00:00:00")};
+ DataSet data_set = {{{vec, std::string("2022-01-02 00:00:00")}, UInt8(1)},
+ {{vec, std::string("")}, UInt8(1)},
+ {{vec, std::string("2022-01-03 00:00:00")}, UInt8(0)},
+ {{Null(), std::string("2022-01-04 00:00:00")}, Null()},
+ {{empty_arr, std::string("2022-01-02 00:00:00")}, UInt8(0)}};
+
+ check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
+ }
+
+ // array_contains(Array<Decimal128>, Decimal128)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Decimal128, TypeIndex::Decimal128};
+
+ Array vec = {ut_type::DECIMALFIELD(17014116.67), ut_type::DECIMALFIELD(-17014116.67),
+ ut_type::DECIMALFIELD(0.0)};
+ DataSet data_set = {{{vec, ut_type::DECIMAL(-17014116.67)}, UInt8(1)},
+ {{vec, ut_type::DECIMAL(0)}, UInt8(1)},
+ {{Null(), ut_type::DECIMAL(0)}, Null()},
+ {{empty_arr, ut_type::DECIMAL(0)}, UInt8(0)}};
+
+ check_function<DataTypeUInt8, true>(func_name, input_types, data_set);
+ }
+
// array_contains(Array<String>, String)
{
InputTypeSet input_types = {TypeIndex::Array, TypeIndex::String, TypeIndex::String};
@@ -128,6 +211,50 @@ TEST(function_array_index_test, array_position) {
check_function<DataTypeInt64, true>(func_name, input_types, data_set);
}
+ // array_position(Array<Date>, Date)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Date, TypeIndex::Date};
+
+ Array vec = {str_to_data_time("2022-01-02", false), str_to_data_time("", false),
+ str_to_data_time("2022-07-08", false)};
+ DataSet data_set = {{{vec, std::string("2022-01-02")}, Int64(1)},
+ {{vec, std::string("")}, Int64(2)},
+ {{vec, std::string("2022-01-03")}, Int64(0)},
+ {{Null(), std::string("2022-01-04")}, Null()},
+ {{empty_arr, std::string("2022-01-02")}, Int64(0)}};
+
+ check_function<DataTypeInt64, true>(func_name, input_types, data_set);
+ }
+
+ // array_position(Array<DateTime>, DateTime)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::DateTime, TypeIndex::DateTime};
+
+ Array vec = {str_to_data_time("2022-01-02 00:00:00"), str_to_data_time(""),
+ str_to_data_time("2022-07-08 00:00:00")};
+ DataSet data_set = {{{vec, std::string("2022-01-02 00:00:00")}, Int64(1)},
+ {{vec, std::string("")}, Int64(2)},
+ {{vec, std::string("2022-01-03 00:00:00")}, Int64(0)},
+ {{Null(), std::string("2022-01-04 00:00:00")}, Null()},
+ {{empty_arr, std::string("2022-01-02 00:00:00")}, Int64(0)}};
+
+ check_function<DataTypeInt64, true>(func_name, input_types, data_set);
+ }
+
+ // array_position(Array<Decimal128>, Decimal128)
+ {
+ InputTypeSet input_types = {TypeIndex::Array, TypeIndex::Decimal128, TypeIndex::Decimal128};
+
+ Array vec = {ut_type::DECIMALFIELD(17014116.67), ut_type::DECIMALFIELD(-17014116.67),
+ ut_type::DECIMALFIELD(0)};
+ DataSet data_set = {{{vec, ut_type::DECIMAL(-17014116.67)}, Int64(2)},
+ {{vec, ut_type::DECIMAL(0)}, Int64(3)},
+ {{Null(), ut_type::DECIMAL(0)}, Null()},
+ {{empty_arr, ut_type::DECIMAL(0)}, Int64(0)}};
+
+ check_function<DataTypeInt64, true>(func_name, input_types, data_set);
+ }
+
// array_position(Array<String>, String)
{
InputTypeSet input_types = {TypeIndex::Array, TypeIndex::String, TypeIndex::String};
diff --git a/be/test/vec/function/function_test_util.cpp b/be/test/vec/function/function_test_util.cpp
index 91fa39abed..2d8ef33fee 100644
--- a/be/test/vec/function/function_test_util.cpp
+++ b/be/test/vec/function/function_test_util.cpp
@@ -70,6 +70,10 @@ size_t type_index_to_data_type(const std::vector<std::any>& input_types, size_t
desc.type = doris_udf::FunctionContext::TYPE_LARGEINT;
type = std::make_shared<DataTypeInt128>();
return 1;
+ case TypeIndex::Float32:
+ desc.type = doris_udf::FunctionContext::TYPE_FLOAT;
+ type = std::make_shared<DataTypeFloat32>();
+ return 1;
case TypeIndex::Float64:
desc.type = doris_udf::FunctionContext::TYPE_DOUBLE;
type = std::make_shared<DataTypeFloat64>();
@@ -84,7 +88,7 @@ size_t type_index_to_data_type(const std::vector<std::any>& input_types, size_t
return 1;
case TypeIndex::Date:
desc.type = doris_udf::FunctionContext::TYPE_DATE;
- type = std::make_shared<DataTypeDateTime>();
+ type = std::make_shared<DataTypeDate>();
return 1;
case TypeIndex::Array: {
desc.type = doris_udf::FunctionContext::TYPE_ARRAY;
@@ -152,6 +156,9 @@ bool insert_cell(MutableColumnPtr& column, DataTypePtr type_ptr, const std::any&
} else if (type.is_int128()) {
auto value = std::any_cast<ut_type::LARGEINT>(cell);
column->insert_data(reinterpret_cast<char*>(&value), 0);
+ } else if (type.is_float32()) {
+ auto value = std::any_cast<ut_type::FLOAT>(cell);
+ column->insert_data(reinterpret_cast<char*>(&value), 0);
} else if (type.is_float64()) {
auto value = std::any_cast<ut_type::DOUBLE>(cell);
column->insert_data(reinterpret_cast<char*>(&value), 0);
diff --git a/be/test/vec/function/function_test_util.h b/be/test/vec/function/function_test_util.h
index 76457131e5..8765ec83fb 100644
--- a/be/test/vec/function/function_test_util.h
+++ b/be/test/vec/function/function_test_util.h
@@ -58,7 +58,10 @@ using STRING = std::string;
using DOUBLE = double;
using FLOAT = float;
-inline auto DECIMAL = Decimal<Int128>::double_to_decimal;
+inline auto DECIMAL = Decimal128::double_to_decimal;
+inline auto DECIMALFIELD = [](double v) {
+ return DecimalField<Decimal128>(Decimal128::double_to_decimal(v), 9);
+};
using DATETIME = std::string;
@@ -179,11 +182,16 @@ void check_function(const std::string& func_name, const InputTypeSet& input_type
Field field;
column->get(i, field);
- const auto& column_data = field.get<typename ReturnType::FieldType>();
const auto& expect_data =
std::any_cast<typename ReturnType::FieldType>(data_set[i].second);
- EXPECT_EQ(column_data, expect_data);
+ if constexpr (std::is_same_v<ReturnType, DataTypeDecimal<Decimal128>>) {
+ const auto& column_data = field.get<DecimalField<Decimal128>>().get_value();
+ EXPECT_EQ(column_data.value, expect_data.value);
+ } else {
+ const auto& column_data = field.get<typename ReturnType::FieldType>();
+ EXPECT_EQ(column_data, expect_data);
+ }
};
if constexpr (nullable) {
diff --git a/gensrc/script/doris_builtins_functions.py b/gensrc/script/doris_builtins_functions.py
index d655de36fc..2d2d7d1bbf 100755
--- a/gensrc/script/doris_builtins_functions.py
+++ b/gensrc/script/doris_builtins_functions.py
@@ -117,67 +117,47 @@ visible_functions = [
[['array'], 'ARRAY', ['ARRAY', '...'], '', '', '', '', ''],
[['array'], 'ARRAY', ['MAP', '...'], '', '', '', '', ''],
[['array'], 'ARRAY', ['STRUCT', '...'], '', '', '', '', ''],
- [['%element_extract%'], 'VARCHAR', ['MAP', 'VARCHAR'], '', '', '', '', ''],
- [['%element_extract%'], 'VARCHAR', ['MAP', 'INT'], '', '', '', '', ''],
- [['%element_extract%'], 'VARCHAR', ['STRUCT', 'INT'], '', '', '', '', ''],
- [['%element_extract%'], 'VARCHAR', ['STRUCT', 'VARCHAR'], '', '', '', '', ''],
- [['element_at', '%element_extract%'], 'TINYINT', ['ARRAY_TINYINT', 'INT'],
- '_ZN5doris10vectorized20FunctionArrayElement12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['element_at', '%element_extract%'], 'SMALLINT', ['ARRAY_SMALLINT', 'INT'],
- '_ZN5doris10vectorized20FunctionArrayElement12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['element_at', '%element_extract%'], 'INT', ['ARRAY_INT', 'INT'],
- '_ZN5doris10vectorized20FunctionArrayElement12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['element_at', '%element_extract%'], 'BIGINT', ['ARRAY_BIGINT', 'INT'],
- '_ZN5doris10vectorized20FunctionArrayElement12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['element_at', '%element_extract%'], 'VARCHAR', ['ARRAY_VARCHAR', 'INT'],
- '_ZN5doris10vectorized20FunctionArrayElement12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['element_at', '%element_extract%'], 'STRING', ['ARRAY_STRING', 'INT'],
- '_ZN5doris10vectorized20FunctionArrayElement12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
-
- [['array_contains'], 'BOOLEAN', ['ARRAY', 'TINYINT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayContainsActionENS0_17NameArrayContainsEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_contains'], 'BOOLEAN', ['ARRAY', 'SMALLINT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayContainsActionENS0_17NameArrayContainsEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_contains'], 'BOOLEAN', ['ARRAY', 'INT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayContainsActionENS0_17NameArrayContainsEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_contains'], 'BOOLEAN', ['ARRAY', 'BIGINT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayContainsActionENS0_17NameArrayContainsEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_contains'], 'BOOLEAN', ['ARRAY', 'VARCHAR'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayContainsActionENS0_17NameArrayContainsEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_contains'], 'BOOLEAN', ['ARRAY', 'STRING'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayContainsActionENS0_17NameArrayContainsEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
-
- [['array_position'], 'BIGINT', ['ARRAY', 'TINYINT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayPositionActionENS0_17NameArrayPositionEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_position'], 'BIGINT', ['ARRAY', 'SMALLINT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayPositionActionENS0_17NameArrayPositionEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_position'], 'BIGINT', ['ARRAY', 'INT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayPositionActionENS0_17NameArrayPositionEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_position'], 'BIGINT', ['ARRAY', 'BIGINT'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayPositionActionENS0_17NameArrayPositionEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_position'], 'BIGINT', ['ARRAY', 'VARCHAR'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayPositionActionENS0_17NameArrayPositionEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
- [['array_position'], 'BIGINT', ['ARRAY', 'STRING'],
- '_ZN5doris10vectorized18FunctionArrayIndexINS0_19ArrayPositionActionENS0_17NameArrayPositionEE12execute_implEPN9doris_udf15FunctionContextERNS0_5BlockERKSt6vectorImSaImEEmm',
- '', '', 'vec', ''],
+ [['element_at', '%element_extract%'], 'BOOLEAN', ['ARRAY_BOOLEAN', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'TINYINT', ['ARRAY_TINYINT', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'SMALLINT', ['ARRAY_SMALLINT', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'INT', ['ARRAY_INT', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'BIGINT', ['ARRAY_BIGINT', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'LARGEINT', ['ARRAY_LARGEINT', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'DATETIME', ['ARRAY_DATETIME', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'DATE', ['ARRAY_DATE', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'FLOAT', ['ARRAY_FLOAT', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'DOUBLE', ['ARRAY_DOUBLE', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'DECIMALV2', ['ARRAY_DECIMALV2', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'VARCHAR', ['ARRAY_VARCHAR', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ [['element_at', '%element_extract%'], 'STRING', ['ARRAY_STRING', 'BIGINT'], '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+
+ [['array_contains'], 'BOOLEAN', ['ARRAY_TINYINT', 'TINYINT'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_SMALLINT', 'SMALLINT'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_INT', 'INT'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_BIGINT', 'BIGINT'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_LARGEINT', 'LARGEINT'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_DATETIME', 'DATETIME'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_DATE', 'DATE'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_FLOAT', 'FLOAT'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_DOUBLE', 'DOUBLE'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_DECIMALV2', 'DECIMALV2'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_VARCHAR', 'VARCHAR'], '', '', '', 'vec', ''],
+ [['array_contains'], 'BOOLEAN', ['ARRAY_STRING', 'STRING'], '', '', '', 'vec', ''],
+
+ [['array_position'], 'BIGINT', ['ARRAY_BOOLEAN', 'BOOLEAN'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_TINYINT', 'TINYINT'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_SMALLINT', 'SMALLINT'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_INT', 'INT'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_BIGINT', 'BIGINT'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_LARGEINT', 'LARGEINT'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_DATETIME', 'DATETIME'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_DATE', 'DATE'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_FLOAT', 'FLOAT'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_DOUBLE', 'DOUBLE'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_DECIMALV2', 'DECIMALV2'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_VARCHAR', 'VARCHAR'], '', '', '', 'vec', ''],
+ [['array_position'], 'BIGINT', ['ARRAY_STRING', 'STRING'], '', '', '', 'vec', ''],
# Timestamp functions
[['unix_timestamp'], 'INT', [],
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org