This is an automated email from the ASF dual-hosted git repository.
morningman pushed a commit to branch branch-1.2-lts
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/branch-1.2-lts by this push:
new 474a946e8c [cherrypick](1.2) pick 5 date/decimal commits (#16320)
474a946e8c is described below
commit 474a946e8c7e3af6587c608e74e0e28adc7bb724
Author: Gabriel <[email protected]>
AuthorDate: Thu Feb 2 10:00:25 2023 +0800
[cherrypick](1.2) pick 5 date/decimal commits (#16320)
#15541 #16295 #16281 #16247 #16159 #16330
---
be/src/vec/functions/date_time_transforms.h | 70 +++-
be/src/vec/functions/function.h | 11 +
.../function_date_or_datetime_computation.h | 324 +++++++++++++-----
.../function_date_or_datetime_to_something.h | 16 +-
.../function_date_or_datetime_to_string.h | 35 +-
.../vec/functions/function_datetime_floor_ceil.cpp | 9 +-
be/src/vec/functions/function_timestamp.cpp | 369 ++++++++++++++++-----
.../java/org/apache/doris/catalog/ScalarType.java | 2 +-
.../apache/doris/analysis/FunctionCallExpr.java | 3 +-
.../expressions/functions/scalar/MinuteCeil.java | 8 +-
.../expressions/functions/scalar/MinuteFloor.java | 8 +-
gensrc/script/doris_builtins_functions.py | 269 ++++++---------
.../sql_functions/math_functions/test_round.out | 12 +
.../sql_functions/math_functions/test_round.groovy | 4 +
14 files changed, 775 insertions(+), 365 deletions(-)
diff --git a/be/src/vec/functions/date_time_transforms.h
b/be/src/vec/functions/date_time_transforms.h
index d07d258dd3..28476bdac5 100644
--- a/be/src/vec/functions/date_time_transforms.h
+++ b/be/src/vec/functions/date_time_transforms.h
@@ -34,6 +34,7 @@
#include "vec/data_types/data_type_date_time.h"
#include "vec/data_types/data_type_string.h"
#include "vec/runtime/vdatetime_value.h"
+#include "vec/utils/util.hpp"
namespace doris::vectorized {
@@ -251,6 +252,24 @@ struct TransformerToStringOneArgument {
null_map[i] = !date_time_value.is_valid_date();
}
}
+
+ static void vector(FunctionContext* context,
+ const PaddedPODArray<typename Transform::OpArgType>& ts,
+ ColumnString::Chars& res_data, ColumnString::Offsets&
res_offsets) {
+ const auto len = ts.size();
+ res_data.resize(len * Transform::max_size);
+ res_offsets.resize(len);
+
+ size_t offset = 0;
+ for (int i = 0; i < len; ++i) {
+ const auto& t = ts[i];
+ const auto& date_time_value =
+ reinterpret_cast<const typename DateTraits<typename
Transform::OpArgType>::T&>(
+ t);
+ res_offsets[i] = Transform::execute(date_time_value, res_data,
offset);
+ DCHECK(date_time_value.is_valid_date());
+ }
+ }
};
template <typename Transform>
@@ -298,6 +317,17 @@ struct Transformer {
.is_valid_date();
}
}
+
+ static void vector(const PaddedPODArray<FromType>& vec_from,
PaddedPODArray<ToType>& vec_to) {
+ size_t size = vec_from.size();
+ vec_to.resize(size);
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from[i]);
+ DCHECK(((typename DateTraits<typename
Transform::OpArgType>::T&)(vec_from[i]))
+ .is_valid_date());
+ }
+ }
};
template <typename FromType, typename ToType>
@@ -320,21 +350,49 @@ struct Transformer<FromType, ToType,
ToYearImpl<FromType>> {
null_map_ptr[i] = to_ptr[i] > MAX_YEAR;
}
}
+
+ static void vector(const PaddedPODArray<FromType>& vec_from,
PaddedPODArray<ToType>& vec_to) {
+ size_t size = vec_from.size();
+ vec_to.resize(size);
+
+ auto* __restrict to_ptr = vec_to.data();
+ auto* __restrict from_ptr = vec_from.data();
+
+ for (size_t i = 0; i < size; ++i) {
+ to_ptr[i] = ToYearImpl<FromType>::execute(from_ptr[i]);
+ }
+ }
};
template <typename FromType, typename ToType, typename Transform>
struct DateTimeTransformImpl {
static Status execute(Block& block, const ColumnNumbers& arguments, size_t
result,
- size_t /*input_rows_count*/) {
+ size_t input_rows_count) {
using Op = Transformer<FromType, ToType, Transform>;
- const ColumnPtr source_col =
block.get_by_position(arguments[0]).column;
+ const auto is_nullable =
block.get_by_position(result).type->is_nullable();
+
+ const ColumnPtr source_col =
remove_nullable(block.get_by_position(arguments[0]).column);
if (const auto* sources =
check_and_get_column<ColumnVector<FromType>>(source_col.get())) {
auto col_to = ColumnVector<ToType>::create();
- auto null_map = ColumnVector<UInt8>::create();
- Op::vector(sources->get_data(), col_to->get_data(),
null_map->get_data());
- block.replace_by_position(
- result, ColumnNullable::create(std::move(col_to),
std::move(null_map)));
+ if (is_nullable) {
+ auto null_map = ColumnVector<UInt8>::create(input_rows_count);
+ Op::vector(sources->get_data(), col_to->get_data(),
null_map->get_data());
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[0]).column.get()))
{
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ block.replace_by_position(
+ result, ColumnNullable::create(std::move(col_to),
std::move(null_map)));
+ } else {
+ Op::vector(sources->get_data(), col_to->get_data());
+ block.replace_by_position(result, std::move(col_to));
+ }
} else {
return Status::RuntimeError("Illegal column {} of first argument
of function {}",
block.get_by_position(arguments[0]).column->get_name(),
diff --git a/be/src/vec/functions/function.h b/be/src/vec/functions/function.h
index 9e00f36a33..fa71a38a50 100644
--- a/be/src/vec/functions/function.h
+++ b/be/src/vec/functions/function.h
@@ -29,6 +29,17 @@
namespace doris::vectorized {
+#define RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(TYPE)
\
+ bool is_nullable = false;
\
+ bool is_datev2 = false;
\
+ for (auto it : arguments) {
\
+ is_nullable = is_nullable || it.type->is_nullable();
\
+ is_datev2 = is_datev2 ||
WhichDataType(remove_nullable(it.type)).is_date_v2() || \
+ WhichDataType(remove_nullable(it.type)).is_date_time_v2();
\
+ }
\
+ return is_nullable || !is_datev2 ? make_nullable(std::make_shared<TYPE>())
\
+ : std::make_shared<TYPE>();
+
class Field;
// Only use dispose the variadic argument
diff --git a/be/src/vec/functions/function_date_or_datetime_computation.h
b/be/src/vec/functions/function_date_or_datetime_computation.h
index a4d51c972c..ee33e82cf7 100644
--- a/be/src/vec/functions/function_date_or_datetime_computation.h
+++ b/be/src/vec/functions/function_date_or_datetime_computation.h
@@ -31,6 +31,8 @@
#include "vec/functions/function.h"
#include "vec/functions/function_helpers.h"
#include "vec/runtime/vdatetime_value.h"
+#include "vec/utils/util.hpp"
+
namespace doris::vectorized {
template <TimeUnit unit, typename DateValueType, typename ResultDateValueType,
typename ResultType,
@@ -303,6 +305,21 @@ struct DateTimeOp {
reinterpret_cast<bool&>(null_map[i]));
}
}
+ static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
+ const PaddedPODArray<FromType2>& vec_from1,
+ PaddedPODArray<ToType>& vec_to) {
+ size_t size = vec_from0.size();
+ vec_to.resize(size);
+
+ bool invalid = true;
+ for (size_t i = 0; i < size; ++i) {
+ // here reinterpret_cast is used to convert uint8& to bool&,
+ // otherwise it will be implicitly converted to bool, causing the
rvalue to fail to match the lvalue.
+ // the same goes for the following.
+ vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i],
invalid);
+ DCHECK(!invalid);
+ }
+ }
// use for (DateTime, int32) -> other_type
static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
@@ -316,6 +333,18 @@ struct DateTimeOp {
vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i],
reinterpret_cast<bool&>(null_map[i]));
}
+ static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
+ const PaddedPODArray<Int32>& vec_from1,
+ PaddedPODArray<ToType>& vec_to) {
+ size_t size = vec_from0.size();
+ vec_to.resize(size);
+
+ bool invalid = true;
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i],
invalid);
+ DCHECK(!invalid);
+ }
+ }
// use for (DateTime, const DateTime) -> other_type
static void vector_constant(const PaddedPODArray<FromType1>& vec_from,
@@ -329,6 +358,17 @@ struct DateTimeOp {
Transform::execute(vec_from[i], delta,
reinterpret_cast<bool&>(null_map[i]));
}
}
+ static void vector_constant(const PaddedPODArray<FromType1>& vec_from,
+ PaddedPODArray<ToType>& vec_to, Int128& delta)
{
+ size_t size = vec_from.size();
+ vec_to.resize(size);
+
+ bool invalid = true;
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from[i], delta, invalid);
+ DCHECK(!invalid);
+ }
+ }
// use for (DateTime, const ColumnNumber) -> other_type
static void vector_constant(const PaddedPODArray<FromType1>& vec_from,
@@ -342,6 +382,17 @@ struct DateTimeOp {
Transform::execute(vec_from[i], delta,
reinterpret_cast<bool&>(null_map[i]));
}
}
+ static void vector_constant(const PaddedPODArray<FromType1>& vec_from,
+ PaddedPODArray<ToType>& vec_to, Int64 delta) {
+ size_t size = vec_from.size();
+ vec_to.resize(size);
+ bool invalid = true;
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from[i], delta, invalid);
+ DCHECK(!invalid);
+ }
+ }
// use for (const DateTime, ColumnNumber) -> other_type
static void constant_vector(const FromType1& from, PaddedPODArray<ToType>&
vec_to,
@@ -355,6 +406,17 @@ struct DateTimeOp {
reinterpret_cast<bool&>(null_map[i]));
}
}
+ static void constant_vector(const FromType1& from, PaddedPODArray<ToType>&
vec_to,
+ const IColumn& delta) {
+ size_t size = delta.size();
+ vec_to.resize(size);
+ bool invalid = true;
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(from, delta.get_int(i), invalid);
+ DCHECK(!invalid);
+ }
+ }
static void constant_vector(const FromType1& from, PaddedPODArray<ToType>&
vec_to,
NullMap& null_map, const
PaddedPODArray<FromType2>& delta) {
@@ -366,71 +428,164 @@ struct DateTimeOp {
vec_to[i] = Transform::execute(from, delta[i],
reinterpret_cast<bool&>(null_map[i]));
}
}
+ static void constant_vector(const FromType1& from, PaddedPODArray<ToType>&
vec_to,
+ const PaddedPODArray<FromType2>& delta) {
+ size_t size = delta.size();
+ vec_to.resize(size);
+ bool invalid = true;
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(from, delta[i], invalid);
+ DCHECK(!invalid);
+ }
+ }
};
template <typename FromType1, typename Transform, typename FromType2 =
FromType1>
struct DateTimeAddIntervalImpl {
- static Status execute(Block& block, const ColumnNumbers& arguments, size_t
result) {
+ static Status execute(Block& block, const ColumnNumbers& arguments, size_t
result,
+ size_t input_rows_count) {
using ToType = typename Transform::ReturnType::FieldType;
using Op = DateTimeOp<FromType1, FromType2, ToType, Transform>;
- const ColumnPtr source_col =
block.get_by_position(arguments[0]).column;
+ const ColumnPtr source_col =
remove_nullable(block.get_by_position(arguments[0]).column);
+ const auto is_nullable =
block.get_by_position(result).type->is_nullable();
if (const auto* sources =
check_and_get_column<ColumnVector<FromType1>>(source_col.get())) {
auto col_to = ColumnVector<ToType>::create();
- auto null_map = ColumnUInt8::create();
- const IColumn& delta_column =
*block.get_by_position(arguments[1]).column;
-
- if (const auto* delta_const_column = typeid_cast<const
ColumnConst*>(&delta_column)) {
- if (delta_const_column->get_field().get_type() ==
Field::Types::Int128) {
- Op::vector_constant(sources->get_data(),
col_to->get_data(),
- null_map->get_data(),
-
delta_const_column->get_field().get<Int128>());
- } else if (delta_const_column->get_field().get_type() ==
Field::Types::Int64) {
- Op::vector_constant(sources->get_data(),
col_to->get_data(),
- null_map->get_data(),
-
delta_const_column->get_field().get<Int64>());
- } else if (delta_const_column->get_field().get_type() ==
Field::Types::UInt64) {
- Op::vector_constant(sources->get_data(),
col_to->get_data(),
- null_map->get_data(),
-
delta_const_column->get_field().get<UInt64>());
+ const IColumn& delta_column =
+
*remove_nullable(block.get_by_position(arguments[1]).column);
+
+ if (is_nullable) {
+ auto null_map = ColumnUInt8::create(input_rows_count, 0);
+ if (const auto* delta_const_column =
+ typeid_cast<const ColumnConst*>(&delta_column)) {
+ if (delta_const_column->get_field().get_type() ==
Field::Types::Int128) {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+ null_map->get_data(),
+
delta_const_column->get_field().get<Int128>());
+ } else if (delta_const_column->get_field().get_type() ==
Field::Types::Int64) {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+ null_map->get_data(),
+
delta_const_column->get_field().get<Int64>());
+ } else if (delta_const_column->get_field().get_type() ==
Field::Types::UInt64) {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+ null_map->get_data(),
+
delta_const_column->get_field().get<UInt64>());
+ } else {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+ null_map->get_data(),
+
delta_const_column->get_field().get<Int32>());
+ }
} else {
- Op::vector_constant(sources->get_data(),
col_to->get_data(),
- null_map->get_data(),
-
delta_const_column->get_field().get<Int32>());
+ if (const auto* delta_vec_column0 =
+
check_and_get_column<ColumnVector<FromType2>>(delta_column)) {
+ Op::vector_vector(sources->get_data(),
delta_vec_column0->get_data(),
+ col_to->get_data(),
null_map->get_data());
+ } else {
+ const auto* delta_vec_column1 =
+
check_and_get_column<ColumnVector<Int32>>(delta_column);
+ DCHECK(delta_vec_column1 != nullptr);
+ Op::vector_vector(sources->get_data(),
delta_vec_column1->get_data(),
+ col_to->get_data(),
null_map->get_data());
+ }
+ }
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[0]).column.get()))
{
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
}
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[1]).column.get()))
{
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ block.get_by_position(result).column =
+ ColumnNullable::create(std::move(col_to),
std::move(null_map));
} else {
- if (const auto* delta_vec_column0 =
-
check_and_get_column<ColumnVector<FromType2>>(delta_column)) {
- Op::vector_vector(sources->get_data(),
delta_vec_column0->get_data(),
- col_to->get_data(),
null_map->get_data());
+ if (const auto* delta_const_column =
+ typeid_cast<const ColumnConst*>(&delta_column)) {
+ if (delta_const_column->get_field().get_type() ==
Field::Types::Int128) {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+
delta_const_column->get_field().get<Int128>());
+ } else if (delta_const_column->get_field().get_type() ==
Field::Types::Int64) {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+
delta_const_column->get_field().get<Int64>());
+ } else if (delta_const_column->get_field().get_type() ==
Field::Types::UInt64) {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+
delta_const_column->get_field().get<UInt64>());
+ } else {
+ Op::vector_constant(sources->get_data(),
col_to->get_data(),
+
delta_const_column->get_field().get<Int32>());
+ }
} else {
- const auto* delta_vec_column1 =
-
check_and_get_column<ColumnVector<Int32>>(delta_column);
- DCHECK(delta_vec_column1 != nullptr);
- Op::vector_vector(sources->get_data(),
delta_vec_column1->get_data(),
- col_to->get_data(),
null_map->get_data());
+ if (const auto* delta_vec_column0 =
+
check_and_get_column<ColumnVector<FromType2>>(delta_column)) {
+ Op::vector_vector(sources->get_data(),
delta_vec_column0->get_data(),
+ col_to->get_data());
+ } else {
+ const auto* delta_vec_column1 =
+
check_and_get_column<ColumnVector<Int32>>(delta_column);
+ DCHECK(delta_vec_column1 != nullptr);
+ Op::vector_vector(sources->get_data(),
delta_vec_column1->get_data(),
+ col_to->get_data());
+ }
}
+ block.replace_by_position(result, std::move(col_to));
}
-
- block.get_by_position(result).column =
- ColumnNullable::create(std::move(col_to),
std::move(null_map));
} else if (const auto* sources_const =
check_and_get_column_const<ColumnVector<FromType1>>(source_col.get())) {
auto col_to = ColumnVector<ToType>::create();
- auto null_map = ColumnUInt8::create();
-
- if (const auto* delta_vec_column =
check_and_get_column<ColumnVector<FromType2>>(
- *block.get_by_position(arguments[1]).column)) {
- Op::constant_vector(sources_const->template
get_value<FromType1>(),
- col_to->get_data(), null_map->get_data(),
- delta_vec_column->get_data());
+ if (is_nullable) {
+ auto null_map = ColumnUInt8::create(input_rows_count, 0);
+ if (const auto* delta_vec_column =
check_and_get_column<ColumnVector<FromType2>>(
+
*remove_nullable(block.get_by_position(arguments[1]).column))) {
+ Op::constant_vector(sources_const->template
get_value<FromType1>(),
+ col_to->get_data(),
delta_vec_column->get_data());
+ } else {
+ Op::constant_vector(
+ sources_const->template get_value<FromType2>(),
col_to->get_data(),
+
*remove_nullable(block.get_by_position(arguments[1]).column));
+ }
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[0]).column.get()))
{
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[1]).column.get()))
{
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ block.get_by_position(result).column =
+ ColumnNullable::create(std::move(col_to),
std::move(null_map));
} else {
- Op::constant_vector(sources_const->template
get_value<FromType2>(),
- col_to->get_data(), null_map->get_data(),
-
*block.get_by_position(arguments[1]).column);
+ if (const auto* delta_vec_column =
check_and_get_column<ColumnVector<FromType2>>(
+ *block.get_by_position(arguments[1]).column)) {
+ Op::constant_vector(sources_const->template
get_value<FromType1>(),
+ col_to->get_data(),
delta_vec_column->get_data());
+ } else {
+ Op::constant_vector(sources_const->template
get_value<FromType2>(),
+ col_to->get_data(),
+
*block.get_by_position(arguments[1]).column);
+ }
+ block.replace_by_position(result, std::move(col_to));
}
- block.get_by_position(result).column =
- ColumnNullable::create(std::move(col_to),
std::move(null_map));
} else {
return Status::RuntimeError("Illegal column {} of first argument
of function {}",
block.get_by_position(arguments[0]).column->get_name(),
@@ -458,6 +613,7 @@ public:
if constexpr (has_variadic_argument) return
Transform::get_variadic_argument_types();
return {};
}
+ bool use_default_implementation_for_nulls() const override { return false;
}
DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments)
const override {
if (arguments.size() != 2 && arguments.size() != 3) {
@@ -468,8 +624,8 @@ public:
}
if (arguments.size() == 2) {
- if (!is_date_or_datetime(arguments[0].type) &&
- !is_date_v2_or_datetime_v2(arguments[0].type)) {
+ if (!is_date_or_datetime(remove_nullable(arguments[0].type)) &&
+
!is_date_v2_or_datetime_v2(remove_nullable(arguments[0].type))) {
LOG(FATAL) << fmt::format(
"Illegal type {} of argument of function {}. Should be
a date or a date "
"with time",
@@ -487,7 +643,7 @@ public:
get_name());
}
}
- return make_nullable(std::make_shared<typename
Transform::ReturnType>());
+ RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(typename Transform::ReturnType);
}
bool use_default_implementation_for_constants() const override { return
true; }
@@ -502,79 +658,95 @@ public:
if (which1.is_date() && which2.is_date()) {
return DateTimeAddIntervalImpl<DataTypeDate::FieldType, Transform,
DataTypeDate::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_time() && which2.is_date()) {
return DateTimeAddIntervalImpl<DataTypeDateTime::FieldType,
Transform,
DataTypeDate::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_v2() && which2.is_date()) {
return DateTimeAddIntervalImpl<DataTypeDateV2::FieldType,
Transform,
DataTypeDate::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_time_v2() && which2.is_date()) {
return DateTimeAddIntervalImpl<DataTypeDateTimeV2::FieldType,
Transform,
DataTypeDate::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date() && which2.is_date_time()) {
return DateTimeAddIntervalImpl<DataTypeDate::FieldType, Transform,
DataTypeDateTime::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date() && which2.is_date_v2()) {
return DateTimeAddIntervalImpl<DataTypeDate::FieldType, Transform,
DataTypeDateV2::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date() && which2.is_date_time_v2()) {
- return DateTimeAddIntervalImpl<DataTypeDate::FieldType, Transform,
-
DataTypeDateTimeV2::FieldType>::execute(block, arguments,
-
result);
+ return DateTimeAddIntervalImpl<
+ DataTypeDate::FieldType, Transform,
+ DataTypeDateTimeV2::FieldType>::execute(block, arguments,
result,
+ input_rows_count);
} else if (which1.is_date_v2() && which2.is_date_time()) {
return DateTimeAddIntervalImpl<DataTypeDateV2::FieldType,
Transform,
DataTypeDateTime::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_v2() && which2.is_date_v2()) {
return DateTimeAddIntervalImpl<DataTypeDateV2::FieldType,
Transform,
DataTypeDateV2::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_time_v2() && which2.is_date_time()) {
return DateTimeAddIntervalImpl<DataTypeDateTimeV2::FieldType,
Transform,
DataTypeDateTime::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_time_v2() && which2.is_date_time_v2()) {
- return DateTimeAddIntervalImpl<DataTypeDateTimeV2::FieldType,
Transform,
-
DataTypeDateTimeV2::FieldType>::execute(block, arguments,
-
result);
+ return DateTimeAddIntervalImpl<
+ DataTypeDateTimeV2::FieldType, Transform,
+ DataTypeDateTimeV2::FieldType>::execute(block, arguments,
result,
+ input_rows_count);
} else if (which1.is_date_time() && which2.is_date_time()) {
return DateTimeAddIntervalImpl<DataTypeDateTime::FieldType,
Transform,
DataTypeDateTime::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_time() && which2.is_date_v2()) {
return DateTimeAddIntervalImpl<DataTypeDateTime::FieldType,
Transform,
DataTypeDateV2::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date_time() && which2.is_date_time_v2()) {
- return DateTimeAddIntervalImpl<DataTypeDateTime::FieldType,
Transform,
-
DataTypeDateTimeV2::FieldType>::execute(block, arguments,
-
result);
+ return DateTimeAddIntervalImpl<
+ DataTypeDateTime::FieldType, Transform,
+ DataTypeDateTimeV2::FieldType>::execute(block, arguments,
result,
+ input_rows_count);
} else if (which1.is_date_v2() && which2.is_date_time_v2()) {
- return DateTimeAddIntervalImpl<DataTypeDateV2::FieldType,
Transform,
-
DataTypeDateTimeV2::FieldType>::execute(block, arguments,
-
result);
+ return DateTimeAddIntervalImpl<
+ DataTypeDateV2::FieldType, Transform,
+ DataTypeDateTimeV2::FieldType>::execute(block, arguments,
result,
+ input_rows_count);
} else if (which1.is_date_time_v2() && which2.is_date_v2()) {
return DateTimeAddIntervalImpl<DataTypeDateTimeV2::FieldType,
Transform,
DataTypeDateV2::FieldType>::execute(block, arguments,
-
result);
+
result,
+
input_rows_count);
} else if (which1.is_date()) {
return DateTimeAddIntervalImpl<DataTypeDate::FieldType,
Transform>::execute(
- block, arguments, result);
+ block, arguments, result, input_rows_count);
} else if (which1.is_date_time()) {
return DateTimeAddIntervalImpl<DataTypeDateTime::FieldType,
Transform>::execute(
- block, arguments, result);
+ block, arguments, result, input_rows_count);
} else if (which1.is_date_v2()) {
return DateTimeAddIntervalImpl<DataTypeDateV2::FieldType,
Transform>::execute(
- block, arguments, result);
+ block, arguments, result, input_rows_count);
} else if (which1.is_date_time_v2()) {
return DateTimeAddIntervalImpl<DataTypeDateTimeV2::FieldType,
Transform>::execute(
- block, arguments, result);
+ block, arguments, result, input_rows_count);
} else {
return Status::RuntimeError("Illegal type {} of argument of
function {}",
block.get_by_position(arguments[0]).type->get_name(),
diff --git a/be/src/vec/functions/function_date_or_datetime_to_something.h
b/be/src/vec/functions/function_date_or_datetime_to_something.h
index dfac38dd97..5d41c2349f 100644
--- a/be/src/vec/functions/function_date_or_datetime_to_something.h
+++ b/be/src/vec/functions/function_date_or_datetime_to_something.h
@@ -47,29 +47,30 @@ public:
DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments)
const override {
if (arguments.size() == 1) {
- if (!is_date_or_datetime(arguments[0].type) &&
- !is_date_v2_or_datetime_v2(arguments[0].type)) {
+ if (!is_date_or_datetime(remove_nullable(arguments[0].type)) &&
+
!is_date_v2_or_datetime_v2(remove_nullable(arguments[0].type))) {
LOG(FATAL) << fmt::format(
"Illegal type {} of argument of function {}. Should be
a date or a date "
"with time",
arguments[0].type->get_name(), get_name());
}
} else if (arguments.size() == 2) {
- if (!is_date_or_datetime(arguments[0].type) &&
- !is_date_v2_or_datetime_v2(arguments[0].type)) {
+ if (!is_date_or_datetime(remove_nullable(arguments[0].type)) &&
+
!is_date_v2_or_datetime_v2(remove_nullable(arguments[0].type))) {
LOG(FATAL) << fmt::format(
"Illegal type {} of argument of function {}. Should be
a date or a date "
"with time",
arguments[0].type->get_name(), get_name());
}
- if (!is_string(arguments[1].type)) {
+ if (!is_string(remove_nullable(arguments[1].type))) {
LOG(FATAL) << fmt::format(
"Function {} supports 1 or 2 arguments. The 1st
argument must be of type "
"Date or DateTime. The 2nd argument (optional) must be
a constant string "
"with timezone name",
get_name());
}
- if (is_date(arguments[0].type) && std::is_same_v<ToDataType,
DataTypeDate>) {
+ if (is_date(remove_nullable(arguments[0].type)) &&
+ std::is_same_v<ToDataType, DataTypeDate>) {
LOG(FATAL) << fmt::format(
"The timezone argument of function {} is allowed only
when the 1st "
"argument has the type DateTime",
@@ -82,11 +83,12 @@ public:
get_name(), arguments.size());
}
- return make_nullable(std::make_shared<ToDataType>());
+ RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(ToDataType);
}
bool use_default_implementation_for_constants() const override { return
true; }
ColumnNumbers get_arguments_that_are_always_constant() const override {
return {1}; }
+ bool use_default_implementation_for_nulls() const override { return false;
}
Status execute_impl(FunctionContext* context, Block& block, const
ColumnNumbers& arguments,
size_t result, size_t input_rows_count) override {
diff --git a/be/src/vec/functions/function_date_or_datetime_to_string.h
b/be/src/vec/functions/function_date_or_datetime_to_string.h
index c4f07e05b8..a48e934abd 100644
--- a/be/src/vec/functions/function_date_or_datetime_to_string.h
+++ b/be/src/vec/functions/function_date_or_datetime_to_string.h
@@ -37,9 +37,10 @@ public:
String get_name() const override { return name; }
size_t get_number_of_arguments() const override { return 1; }
+ bool use_default_implementation_for_nulls() const override { return false;
}
DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments)
const override {
- return make_nullable(std::make_shared<DataTypeString>());
+ RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(DataTypeString);
}
bool is_variadic() const override { return true; }
@@ -55,17 +56,33 @@ public:
Status execute_impl(FunctionContext* context, Block& block, const
ColumnNumbers& arguments,
size_t result, size_t input_rows_count) override {
const ColumnPtr source_col =
block.get_by_position(arguments[0]).column;
- const auto* sources =
- check_and_get_column<ColumnVector<typename
Transform::OpArgType>>(source_col.get());
+ const auto is_nullable =
block.get_by_position(result).type->is_nullable();
+ const auto* sources = check_and_get_column<ColumnVector<typename
Transform::OpArgType>>(
+ remove_nullable(source_col).get());
auto col_res = ColumnString::create();
- auto null_map = ColumnVector<UInt8>::create();
+
// Support all input of datetime is valind to make sure not null return
if (sources) {
- TransformerToStringOneArgument<Transform>::vector(
- context, sources->get_data(), col_res->get_chars(),
col_res->get_offsets(),
- null_map->get_data());
- block.replace_by_position(
- result, ColumnNullable::create(std::move(col_res),
std::move(null_map)));
+ if (is_nullable) {
+ auto null_map = ColumnVector<UInt8>::create(input_rows_count);
+ TransformerToStringOneArgument<Transform>::vector(
+ context, sources->get_data(), col_res->get_chars(),
col_res->get_offsets(),
+ null_map->get_data());
+ if (const auto* nullable_col =
+
check_and_get_column<ColumnNullable>(source_col.get())) {
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ block.replace_by_position(
+ result, ColumnNullable::create(std::move(col_res),
std::move(null_map)));
+ } else {
+ TransformerToStringOneArgument<Transform>::vector(
+ context, sources->get_data(), col_res->get_chars(),
col_res->get_offsets());
+ block.replace_by_position(result, std::move(col_res));
+ }
} else {
return Status::InternalError("Illegal column {} of first argument
of function {}",
block.get_by_position(arguments[0]).column->get_name(),
diff --git a/be/src/vec/functions/function_datetime_floor_ceil.cpp
b/be/src/vec/functions/function_datetime_floor_ceil.cpp
index 72da82928b..65ebd95e73 100644
--- a/be/src/vec/functions/function_datetime_floor_ceil.cpp
+++ b/be/src/vec/functions/function_datetime_floor_ceil.cpp
@@ -435,13 +435,20 @@ struct TimeRound {
res = origin_date;
auto ts2 = binary_cast<NativeType, DateValueType>(date);
auto& ts1 = (DateValueType&)(res);
-
+ if (!ts2.is_valid_date() || !ts1.is_valid_date()) {
+ is_null = true;
+ return;
+ }
TimeRound<Impl>::template time_round<NativeType, DateValueType>(ts2,
period, ts1, is_null);
}
template <typename NativeType, typename DateValueType>
static void time_round(NativeType date, Int32 period, NativeType& res,
UInt8& is_null) {
auto ts2 = binary_cast<NativeType, DateValueType>(date);
+ if (!ts2.is_valid_date()) {
+ is_null = true;
+ return;
+ }
auto& ts1 = (DateValueType&)(res);
if constexpr (Impl::Unit != WEEK) {
ts1.from_olap_datetime(FIRST_DAY);
diff --git a/be/src/vec/functions/function_timestamp.cpp
b/be/src/vec/functions/function_timestamp.cpp
index a467d7da8d..704fc8f3ff 100644
--- a/be/src/vec/functions/function_timestamp.cpp
+++ b/be/src/vec/functions/function_timestamp.cpp
@@ -411,31 +411,30 @@ struct UnixTimeStampDateImpl {
static DataTypes get_variadic_argument_types() { return
{std::make_shared<DateType>()}; }
static DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName&
arguments) {
- return make_nullable(std::make_shared<DataTypeInt32>());
+ RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(DataTypeInt32);
}
static Status execute_impl(FunctionContext* context, Block& block,
const ColumnNumbers& arguments, size_t result,
size_t input_rows_count) {
const ColumnPtr col_source =
block.get_by_position(arguments[0]).column;
-
auto col_result = ColumnVector<Int32>::create();
auto null_map = ColumnVector<UInt8>::create();
+ auto& col_result_data = col_result->get_data();
col_result->resize(input_rows_count);
- null_map->resize(input_rows_count);
- auto& col_result_data = col_result->get_data();
- auto& null_map_data = null_map->get_data();
+ if constexpr (std::is_same_v<DateType, DataTypeDate>) {
+ null_map->resize(input_rows_count);
+ auto& null_map_data = null_map->get_data();
- for (int i = 0; i < input_rows_count; i++) {
- if (col_source->is_null_at(i)) {
- null_map_data[i] = true;
- continue;
- }
+ for (int i = 0; i < input_rows_count; i++) {
+ if (col_source->is_null_at(i)) {
+ null_map_data[i] = true;
+ continue;
+ }
- StringRef source = col_source->get_data_at(i);
- if constexpr (std::is_same_v<DateType, DataTypeDate>) {
+ StringRef source = col_source->get_data_at(i);
const VecDateTimeValue& ts_value =
reinterpret_cast<const
VecDateTimeValue&>(*source.data);
int64_t timestamp;
@@ -446,34 +445,91 @@ struct UnixTimeStampDateImpl {
null_map_data[i] = false;
col_result_data[i] =
UnixTimeStampImpl::trim_timestamp(timestamp);
}
- } else if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
- const DateV2Value<DateV2ValueType>& ts_value =
- reinterpret_cast<const
DateV2Value<DateV2ValueType>&>(*source.data);
- int64_t timestamp;
- if (!ts_value.unix_timestamp(×tamp,
-
context->impl()->state()->timezone_obj())) {
- null_map_data[i] = true;
- } else {
- null_map_data[i] = false;
+ }
+ block.replace_by_position(
+ result, ColumnNullable::create(std::move(col_result),
std::move(null_map)));
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
+ const auto is_nullable =
block.get_by_position(arguments[0]).type->is_nullable();
+ if (is_nullable) {
+ null_map->resize(input_rows_count);
+ auto& null_map_data = null_map->get_data();
+ for (int i = 0; i < input_rows_count; i++) {
+ if (col_source->is_null_at(i)) {
+ DCHECK(is_nullable);
+ null_map_data[i] = true;
+ continue;
+ }
+
+ StringRef source = col_source->get_data_at(i);
+ const DateV2Value<DateV2ValueType>& ts_value =
+ reinterpret_cast<const
DateV2Value<DateV2ValueType>&>(*source.data);
+ int64_t timestamp;
+ if (!ts_value.unix_timestamp(×tamp,
+
context->impl()->state()->timezone_obj())) {
+ null_map_data[i] = true;
+ } else {
+ null_map_data[i] = false;
+ col_result_data[i] =
UnixTimeStampImpl::trim_timestamp(timestamp);
+ }
+ }
+ block.replace_by_position(
+ result, ColumnNullable::create(std::move(col_result),
std::move(null_map)));
+ } else {
+ for (int i = 0; i < input_rows_count; i++) {
+ DCHECK(!col_source->is_null_at(i));
+ StringRef source = col_source->get_data_at(i);
+ const DateV2Value<DateV2ValueType>& ts_value =
+ reinterpret_cast<const
DateV2Value<DateV2ValueType>&>(*source.data);
+ int64_t timestamp;
+ const auto valid = ts_value.unix_timestamp(
+ ×tamp,
context->impl()->state()->timezone_obj());
+ DCHECK(valid);
col_result_data[i] =
UnixTimeStampImpl::trim_timestamp(timestamp);
}
+ block.replace_by_position(result, std::move(col_result));
+ }
+ } else {
+ const auto is_nullable =
block.get_by_position(arguments[0]).type->is_nullable();
+ if (is_nullable) {
+ null_map->resize(input_rows_count);
+ auto& null_map_data = null_map->get_data();
+ for (int i = 0; i < input_rows_count; i++) {
+ if (col_source->is_null_at(i)) {
+ DCHECK(is_nullable);
+ null_map_data[i] = true;
+ continue;
+ }
+
+ StringRef source = col_source->get_data_at(i);
+ const DateV2Value<DateTimeV2ValueType>& ts_value =
+ reinterpret_cast<const
DateV2Value<DateTimeV2ValueType>&>(*source.data);
+ int64_t timestamp;
+ if (!ts_value.unix_timestamp(×tamp,
+
context->impl()->state()->timezone_obj())) {
+ null_map_data[i] = true;
+ } else {
+ null_map_data[i] = false;
+ col_result_data[i] =
UnixTimeStampImpl::trim_timestamp(timestamp);
+ }
+ }
+ block.replace_by_position(
+ result, ColumnNullable::create(std::move(col_result),
std::move(null_map)));
} else {
- const DateV2Value<DateTimeV2ValueType>& ts_value =
- reinterpret_cast<const
DateV2Value<DateTimeV2ValueType>&>(*source.data);
- int64_t timestamp;
- if (!ts_value.unix_timestamp(×tamp,
-
context->impl()->state()->timezone_obj())) {
- null_map_data[i] = true;
- } else {
- null_map_data[i] = false;
+ for (int i = 0; i < input_rows_count; i++) {
+ DCHECK(!col_source->is_null_at(i));
+ StringRef source = col_source->get_data_at(i);
+ const DateV2Value<DateTimeV2ValueType>& ts_value =
+ reinterpret_cast<const
DateV2Value<DateTimeV2ValueType>&>(*source.data);
+ int64_t timestamp;
+ const auto valid = ts_value.unix_timestamp(
+ ×tamp,
context->impl()->state()->timezone_obj());
+ DCHECK(valid);
col_result_data[i] =
UnixTimeStampImpl::trim_timestamp(timestamp);
}
+ block.replace_by_position(result, std::move(col_result));
}
}
- block.replace_by_position(
- result, ColumnNullable::create(std::move(col_result),
std::move(null_map)));
-
return Status::OK();
}
};
@@ -576,7 +632,7 @@ public:
String get_name() const override { return name; }
- bool use_default_implementation_for_nulls() const override { return true; }
+ bool use_default_implementation_for_nulls() const override { return false;
}
bool use_default_implementation_for_constants() const override { return
true; }
@@ -587,11 +643,17 @@ public:
// input DateTime and Date, return Date
// input DateTimeV2 and DateV2, return DateV2
DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments)
const override {
+ bool is_nullable = false;
+ for (auto it : arguments) {
+ is_nullable = is_nullable || it.type->is_nullable();
+ }
+
if constexpr (std::is_same_v<DateType, DataTypeDateTime> ||
std::is_same_v<DateType, DataTypeDate>) {
return make_nullable(std::make_shared<DataTypeDate>());
} else {
- return make_nullable(std::make_shared<DataTypeDateV2>());
+ return is_nullable ?
make_nullable(std::make_shared<DataTypeDateV2>())
+ : std::make_shared<DataTypeDateV2>();
}
}
@@ -620,38 +682,66 @@ struct LastDayImpl {
static Status execute_impl(FunctionContext* context, Block& block,
const ColumnNumbers& arguments, size_t result,
size_t input_rows_count) {
- auto null_map = ColumnUInt8::create(input_rows_count, 0);
+ const auto is_nullable =
block.get_by_position(result).type->is_nullable();
ColumnPtr res_column;
- ColumnPtr argument_column =
-
block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();
- if constexpr (std::is_same_v<DateType, DataTypeDateTime> ||
- std::is_same_v<DateType, DataTypeDate>) {
- auto data_col = assert_cast<const
ColumnVector<Int64>*>(argument_column.get());
- res_column = ColumnInt64::create(input_rows_count);
- execute_straight<VecDateTimeValue, Int64, Int64>(
- input_rows_count, null_map->get_data(),
data_col->get_data(),
-
static_cast<ColumnVector<Int64>*>(res_column->assume_mutable().get())
- ->get_data());
-
- } else if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
- auto data_col = assert_cast<const
ColumnVector<UInt32>*>(argument_column.get());
- res_column = ColumnVector<UInt32>::create(input_rows_count);
- execute_straight<DateV2Value<DateV2ValueType>, UInt32, UInt32>(
- input_rows_count, null_map->get_data(),
data_col->get_data(),
-
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
- ->get_data());
+ ColumnPtr argument_column =
remove_nullable(block.get_by_position(arguments[0]).column)
+
->convert_to_full_column_if_const();
+ if (is_nullable) {
+ auto null_map = ColumnUInt8::create(input_rows_count, 0);
+ if constexpr (std::is_same_v<DateType, DataTypeDateTime> ||
+ std::is_same_v<DateType, DataTypeDate>) {
+ auto data_col = assert_cast<const
ColumnVector<Int64>*>(argument_column.get());
+ res_column = ColumnInt64::create(input_rows_count);
+ execute_straight<VecDateTimeValue, Int64, Int64>(
+ input_rows_count, null_map->get_data(),
data_col->get_data(),
+
static_cast<ColumnVector<Int64>*>(res_column->assume_mutable().get())
+ ->get_data());
- } else if constexpr (std::is_same_v<DateType, DataTypeDateTimeV2>) {
- auto data_col = assert_cast<const
ColumnVector<UInt64>*>(argument_column.get());
- res_column = ColumnVector<UInt32>::create(input_rows_count);
- execute_straight<DateV2Value<DateTimeV2ValueType>, UInt32, UInt64>(
- input_rows_count, null_map->get_data(),
data_col->get_data(),
-
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
- ->get_data());
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
+ auto data_col = assert_cast<const
ColumnVector<UInt32>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateV2ValueType>, UInt32, UInt32>(
+ input_rows_count, null_map->get_data(),
data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateTimeV2>)
{
+ auto data_col = assert_cast<const
ColumnVector<UInt64>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateTimeV2ValueType>, UInt32,
UInt64>(
+ input_rows_count, null_map->get_data(),
data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+ }
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[0]).column.get())) {
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ block.replace_by_position(result,
+ ColumnNullable::create(res_column,
std::move(null_map)));
+ } else {
+ if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
+ auto data_col = assert_cast<const
ColumnVector<UInt32>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateV2ValueType>, UInt32, UInt32>(
+ input_rows_count, data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateTimeV2>)
{
+ auto data_col = assert_cast<const
ColumnVector<UInt64>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateTimeV2ValueType>, UInt32,
UInt64>(
+ input_rows_count, data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+ }
+ block.replace_by_position(result, std::move(res_column));
}
-
- block.replace_by_position(
- result, ColumnNullable::create(std::move(res_column),
std::move(null_map)));
return Status::OK();
}
@@ -699,6 +789,31 @@ struct LastDayImpl {
}
}
+ template <typename DateValueType, typename ReturnType, typename
InputDateType>
+ static void execute_straight(size_t input_rows_count,
+ const PaddedPODArray<InputDateType>& data_col,
+ PaddedPODArray<ReturnType>& res_data) {
+ for (int i = 0; i < input_rows_count; i++) {
+ if constexpr (std::is_same_v<DateValueType,
DateV2Value<DateV2ValueType>>) {
+ const auto& cur_data = data_col[i];
+ auto ts_value = binary_cast<UInt32, DateValueType>(cur_data);
+ DCHECK(ts_value.is_valid_date());
+ int day = get_last_month_day(ts_value.year(),
ts_value.month());
+ ts_value.template set_time_unit<TimeUnit::DAY>(day);
+ res_data[i] = binary_cast<DateValueType, UInt32>(ts_value);
+ } else {
+ const auto& cur_data = data_col[i];
+ auto ts_value = binary_cast<UInt64, DateValueType>(cur_data);
+ DCHECK(ts_value.is_valid_date());
+ int day = get_last_month_day(ts_value.year(),
ts_value.month());
+ ts_value.template set_time_unit<TimeUnit::DAY>(day);
+ ts_value.set_time(ts_value.year(), ts_value.month(), day, 0,
0, 0, 0);
+ UInt64 cast_value = binary_cast<DateValueType,
UInt64>(ts_value);
+ DataTypeDateTimeV2::cast_to_date_v2(cast_value, res_data[i]);
+ }
+ }
+ }
+
static int get_last_month_day(int year, int month) {
bool is_leap_year = doris::is_leap(year);
if (month == 2) {
@@ -721,37 +836,66 @@ struct MondayImpl {
static Status execute_impl(FunctionContext* context, Block& block,
const ColumnNumbers& arguments, size_t result,
size_t input_rows_count) {
- auto null_map = ColumnUInt8::create(input_rows_count, 0);
+ const auto is_nullable =
block.get_by_position(result).type->is_nullable();
+ ColumnPtr argument_column =
remove_nullable(block.get_by_position(arguments[0]).column)
+
->convert_to_full_column_if_const();
ColumnPtr res_column;
- ColumnPtr argument_column =
-
block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();
- if constexpr (std::is_same_v<DateType, DataTypeDateTime> ||
- std::is_same_v<DateType, DataTypeDate>) {
- auto data_col = assert_cast<const
ColumnVector<Int64>*>(argument_column.get());
- res_column = ColumnInt64::create(input_rows_count);
- execute_straight<VecDateTimeValue, Int64, Int64>(
- input_rows_count, null_map->get_data(),
data_col->get_data(),
-
static_cast<ColumnVector<Int64>*>(res_column->assume_mutable().get())
- ->get_data());
-
- } else if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
- auto data_col = assert_cast<const
ColumnVector<UInt32>*>(argument_column.get());
- res_column = ColumnVector<UInt32>::create(input_rows_count);
- execute_straight<DateV2Value<DateV2ValueType>, UInt32, UInt32>(
- input_rows_count, null_map->get_data(),
data_col->get_data(),
-
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
- ->get_data());
+ if (is_nullable) {
+ auto null_map = ColumnUInt8::create(input_rows_count, 0);
+ if constexpr (std::is_same_v<DateType, DataTypeDateTime> ||
+ std::is_same_v<DateType, DataTypeDate>) {
+ auto data_col = assert_cast<const
ColumnVector<Int64>*>(argument_column.get());
+ res_column = ColumnInt64::create(input_rows_count);
+ execute_straight<VecDateTimeValue, Int64, Int64>(
+ input_rows_count, null_map->get_data(),
data_col->get_data(),
+
static_cast<ColumnVector<Int64>*>(res_column->assume_mutable().get())
+ ->get_data());
- } else if constexpr (std::is_same_v<DateType, DataTypeDateTimeV2>) {
- auto data_col = assert_cast<const
ColumnVector<UInt64>*>(argument_column.get());
- res_column = ColumnVector<UInt32>::create(input_rows_count);
- execute_straight<DateV2Value<DateTimeV2ValueType>, UInt32, UInt64>(
- input_rows_count, null_map->get_data(),
data_col->get_data(),
-
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
- ->get_data());
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
+ auto data_col = assert_cast<const
ColumnVector<UInt32>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateV2ValueType>, UInt32, UInt32>(
+ input_rows_count, null_map->get_data(),
data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateTimeV2>)
{
+ auto data_col = assert_cast<const
ColumnVector<UInt64>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateTimeV2ValueType>, UInt32,
UInt64>(
+ input_rows_count, null_map->get_data(),
data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+ }
+ if (const auto* nullable_col =
check_and_get_column<ColumnNullable>(
+ block.get_by_position(arguments[0]).column.get())) {
+ NullMap& result_null_map =
assert_cast<ColumnUInt8&>(*null_map).get_data();
+ const NullMap& src_null_map =
+ assert_cast<const
ColumnUInt8&>(nullable_col->get_null_map_column())
+ .get_data();
+ VectorizedUtils::update_null_map(result_null_map,
src_null_map);
+ }
+ block.replace_by_position(result,
+ ColumnNullable::create(res_column,
std::move(null_map)));
+ } else {
+ if constexpr (std::is_same_v<DateType, DataTypeDateV2>) {
+ auto data_col = assert_cast<const
ColumnVector<UInt32>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateV2ValueType>, UInt32, UInt32>(
+ input_rows_count, data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+
+ } else if constexpr (std::is_same_v<DateType, DataTypeDateTimeV2>)
{
+ auto data_col = assert_cast<const
ColumnVector<UInt64>*>(argument_column.get());
+ res_column = ColumnVector<UInt32>::create(input_rows_count);
+ execute_straight<DateV2Value<DateTimeV2ValueType>, UInt32,
UInt64>(
+ input_rows_count, data_col->get_data(),
+
static_cast<ColumnVector<UInt32>*>(res_column->assume_mutable().get())
+ ->get_data());
+ }
+ block.replace_by_position(result, std::move(res_column));
}
- block.replace_by_position(
- result, ColumnNullable::create(std::move(res_column),
std::move(null_map)));
return Status::OK();
}
@@ -826,6 +970,49 @@ struct MondayImpl {
}
}
+ template <typename DateValueType, typename ReturnType, typename
InputDateType>
+ static void execute_straight(size_t input_rows_count,
+ const PaddedPODArray<InputDateType>& data_col,
+ PaddedPODArray<ReturnType>& res_data) {
+ for (int i = 0; i < input_rows_count; i++) {
+ if constexpr (std::is_same_v<DateValueType,
DateV2Value<DateV2ValueType>>) {
+ const auto& cur_data = data_col[i];
+ auto ts_value = binary_cast<UInt32, DateValueType>(cur_data);
+ DCHECK(ts_value.is_valid_date());
+ if (is_special_day(ts_value.year(), ts_value.month(),
ts_value.day())) {
+ ts_value.template set_time_unit<TimeUnit::DAY>(1);
+ res_data[i] = binary_cast<DateValueType, UInt32>(ts_value);
+ continue;
+ }
+
+ // day_of_week, from 1(Mon) to 7(Sun)
+ int day_of_week = ts_value.weekday() + 1;
+ int gap_of_monday = day_of_week - 1;
+ TimeInterval interval(DAY, gap_of_monday, true);
+ ts_value.template date_add_interval<DAY>(interval);
+ res_data[i] = binary_cast<DateValueType, UInt32>(ts_value);
+ } else {
+ const auto& cur_data = data_col[i];
+ auto ts_value = binary_cast<UInt64, DateValueType>(cur_data);
+ DCHECK(ts_value.is_valid_date());
+ if (is_special_day(ts_value.year(), ts_value.month(),
ts_value.day())) {
+ ts_value.set_time(ts_value.year(), ts_value.month(), 1, 0,
0, 0, 0);
+ UInt64 cast_value = binary_cast<DateValueType,
UInt64>(ts_value);
+ DataTypeDateTimeV2::cast_to_date_v2(cast_value,
res_data[i]);
+ continue;
+ }
+ // day_of_week, from 1(Mon) to 7(Sun)
+ int day_of_week = ts_value.weekday() + 1;
+ int gap_of_monday = day_of_week - 1;
+ TimeInterval interval(DAY, gap_of_monday, true);
+ ts_value.template date_add_interval<DAY>(interval);
+ ts_value.set_time(ts_value.year(), ts_value.month(),
ts_value.day(), 0, 0, 0, 0);
+ UInt64 cast_value = binary_cast<DateValueType,
UInt64>(ts_value);
+ DataTypeDateTimeV2::cast_to_date_v2(cast_value, res_data[i]);
+ }
+ }
+ }
+
// specially, 1970-01-01, 1970-01-02, 1970-01-03 and 1970-01-04 return
1970-01-01
static bool is_special_day(int year, int month, int day) {
return year == 1970 && month == 1 && day > 0 && day < 5;
diff --git
a/fe/fe-common/src/main/java/org/apache/doris/catalog/ScalarType.java
b/fe/fe-common/src/main/java/org/apache/doris/catalog/ScalarType.java
index d643c24c1a..c555e9a6ff 100644
--- a/fe/fe-common/src/main/java/org/apache/doris/catalog/ScalarType.java
+++ b/fe/fe-common/src/main/java/org/apache/doris/catalog/ScalarType.java
@@ -564,7 +564,7 @@ public class ScalarType extends Type {
case DECIMAL32:
case DECIMAL64:
case DECIMAL128:
- String typeName = Config.enable_decimal_conversion ? "decimal"
: "decimalv3";
+ String typeName = "decimalv3";
if (Strings.isNullOrEmpty(precisionStr)) {
stringBuilder.append(typeName).append("(").append(precision)
.append(", ").append(scale).append(")");
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/analysis/FunctionCallExpr.java
b/fe/fe-core/src/main/java/org/apache/doris/analysis/FunctionCallExpr.java
index 8a312dba50..526d2fd9f6 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/analysis/FunctionCallExpr.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/analysis/FunctionCallExpr.java
@@ -102,7 +102,8 @@ public class FunctionCallExpr extends Expr {
java.util.function.BiFunction<ArrayList<Expr>, Type, Type> roundRule =
(children, returnType) -> {
Preconditions.checkArgument(children != null && children.size() >
0);
if (children.size() == 1 &&
children.get(0).getType().isDecimalV3()) {
- return
ScalarType.createDecimalV3Type(children.get(0).getType().getPrecision(), 0);
+ return
ScalarType.createDecimalV3Type(children.get(0).getType().getPrecision(),
+ ((ScalarType)
children.get(0).getType()).decimalScale());
} else if (children.size() == 2) {
Preconditions.checkArgument(children.get(1) instanceof
IntLiteral
|| (children.get(1) instanceof CastExpr
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteCeil.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteCeil.java
index dedc4c7afe..804aa7ae15 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteCeil.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteCeil.java
@@ -24,7 +24,6 @@ import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSi
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DateTimeType;
import org.apache.doris.nereids.types.DateTimeV2Type;
-import org.apache.doris.nereids.types.DateV2Type;
import org.apache.doris.nereids.types.IntegerType;
import com.google.common.base.Preconditions;
@@ -41,19 +40,14 @@ public class MinuteCeil extends ScalarFunction
public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
FunctionSignature.ret(DateTimeType.INSTANCE).args(DateTimeType.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateTimeV2Type.INSTANCE),
-
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateV2Type.INSTANCE),
FunctionSignature.ret(DateTimeType.INSTANCE).args(DateTimeType.INSTANCE,
DateTimeType.INSTANCE),
FunctionSignature.ret(DateTimeType.INSTANCE).args(DateTimeType.INSTANCE,
IntegerType.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateTimeV2Type.INSTANCE,
DateTimeV2Type.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateTimeV2Type.INSTANCE,
IntegerType.INSTANCE),
-
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateV2Type.INSTANCE,
DateV2Type.INSTANCE),
-
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateV2Type.INSTANCE,
IntegerType.INSTANCE),
FunctionSignature.ret(DateTimeType.INSTANCE)
.args(DateTimeType.INSTANCE, IntegerType.INSTANCE,
DateTimeType.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE)
- .args(DateTimeV2Type.INSTANCE, IntegerType.INSTANCE,
DateTimeV2Type.INSTANCE),
- FunctionSignature.ret(DateTimeV2Type.INSTANCE)
- .args(DateV2Type.INSTANCE, IntegerType.INSTANCE,
DateV2Type.INSTANCE)
+ .args(DateTimeV2Type.INSTANCE, IntegerType.INSTANCE,
DateTimeV2Type.INSTANCE)
);
/**
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteFloor.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteFloor.java
index e999d6193a..a2a7027ad9 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteFloor.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinuteFloor.java
@@ -24,7 +24,6 @@ import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSi
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DateTimeType;
import org.apache.doris.nereids.types.DateTimeV2Type;
-import org.apache.doris.nereids.types.DateV2Type;
import org.apache.doris.nereids.types.IntegerType;
import com.google.common.base.Preconditions;
@@ -41,19 +40,14 @@ public class MinuteFloor extends ScalarFunction
public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
FunctionSignature.ret(DateTimeType.INSTANCE).args(DateTimeType.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateTimeV2Type.INSTANCE),
-
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateV2Type.INSTANCE),
FunctionSignature.ret(DateTimeType.INSTANCE).args(DateTimeType.INSTANCE,
DateTimeType.INSTANCE),
FunctionSignature.ret(DateTimeType.INSTANCE).args(DateTimeType.INSTANCE,
IntegerType.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateTimeV2Type.INSTANCE,
DateTimeV2Type.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateTimeV2Type.INSTANCE,
IntegerType.INSTANCE),
-
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateV2Type.INSTANCE,
DateV2Type.INSTANCE),
-
FunctionSignature.ret(DateTimeV2Type.INSTANCE).args(DateV2Type.INSTANCE,
IntegerType.INSTANCE),
FunctionSignature.ret(DateTimeType.INSTANCE)
.args(DateTimeType.INSTANCE, IntegerType.INSTANCE,
DateTimeType.INSTANCE),
FunctionSignature.ret(DateTimeV2Type.INSTANCE)
- .args(DateTimeV2Type.INSTANCE, IntegerType.INSTANCE,
DateTimeV2Type.INSTANCE),
- FunctionSignature.ret(DateTimeV2Type.INSTANCE)
- .args(DateV2Type.INSTANCE, IntegerType.INSTANCE,
DateV2Type.INSTANCE)
+ .args(DateTimeV2Type.INSTANCE, IntegerType.INSTANCE,
DateTimeV2Type.INSTANCE)
);
/**
diff --git a/gensrc/script/doris_builtins_functions.py
b/gensrc/script/doris_builtins_functions.py
index 92e6c93fcf..a7c7688754 100755
--- a/gensrc/script/doris_builtins_functions.py
+++ b/gensrc/script/doris_builtins_functions.py
@@ -603,10 +603,10 @@ visible_functions = [
'', '', 'vec', 'ALWAYS_NULLABLE'],
[['unix_timestamp'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions7to_unixEPN9doris_udf15FunctionContextERKNS1_11DateV2TimeValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['unix_timestamp'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions7to_unixEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['unix_timestamp'], 'INT', ['VARCHAR', 'VARCHAR'],
'_ZN5doris18TimestampFunctions7to_unixEPN9doris_udf15FunctionContextERKNS1_9StringValES6_',
'', '', 'vec', 'ALWAYS_NULLABLE'],
@@ -660,14 +660,14 @@ visible_functions = [
'', '', 'vec', 'ALWAYS_NULLABLE'],
[['last_day'], 'DATEV2', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions8last_dayEPN9doris_udf15FunctionContextERKNS1_11DateTimeValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['last_day'], 'DATEV2', ['DATEV2'],
'_ZN5doris18TimestampFunctions8last_dayEPN9doris_udf15FunctionContextERKNS1_11DateTimeValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['to_monday'], 'DATEV2', ['DATETIMEV2'],
- '', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', '', 'vec', ''],
[['to_monday'], 'DATEV2', ['DATEV2'],
- '','', '', 'vec', 'ALWAYS_NULLABLE'],
+ '','', '', 'vec', ''],
[['to_monday'], 'DATE', ['DATETIME'],
'', '', '', 'vec', 'ALWAYS_NULLABLE'],
[['to_monday'], 'DATE', ['DATE'],
@@ -1033,160 +1033,160 @@ visible_functions = [
[['timestamp'], 'DATETIMEV2', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions9timestampEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['to_days'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions7to_daysEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['year'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions4yearEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['month'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions5monthEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['quarter'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions7quarterEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['dayofweek'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions11day_of_weekEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weekday'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions8week_dayEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['day', 'dayofmonth'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions12day_of_monthEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['dayofyear'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions11day_of_yearEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['weekofyear'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions12week_of_yearEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['yearweek'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions9year_weekEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['yearweek'], 'INT', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9year_weekEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['week'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions4weekEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['week'], 'INT', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions4weekEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hour'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions4hourEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minute'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions6minuteEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['second'], 'INT', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions6secondEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['year'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions4yearEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['month'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions5monthEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['quarter'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions7quarterEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['dayofweek'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions11day_of_weekEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weekday'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions8week_dayEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['day', 'dayofmonth'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions12day_of_monthEPN9doris_udf'
- '15FunctionContextERKNS1_11DateV2ValE', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateV2ValE', '', '', 'vec', ''],
[['dayofyear'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions11day_of_yearEPN9doris_udf'
- '15FunctionContextERKNS1_11DateV2ValE', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateV2ValE', '', '', 'vec', ''],
[['weekofyear'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions12week_of_yearEPN9doris_udf'
- '15FunctionContextERKNS1_11DateV2ValE', '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateV2ValE', '', '', 'vec', ''],
[['yearweek'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions9year_weekEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['yearweek'], 'INT', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9year_weekEPN9doris_udf15FunctionContextERKNS1_11DateV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['week'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions4weekEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['week'], 'INT', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions4weekEPN9doris_udf15FunctionContextERKNS1_11DateV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hour'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions4hourEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minute'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions6minuteEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['second'], 'INT', ['DATEV2'],
'_ZN5doris18TimestampFunctions6secondEPN9doris_udf15FunctionContextERKNS1_11DateV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['years_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9years_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['years_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9years_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_add', 'add_months'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions10months_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions10months_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9weeks_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9weeks_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_add', 'date_add', 'adddate'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions8days_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_sub', 'date_sub', 'subdate'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions8days_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9hours_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions9hours_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions11minutes_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions11minutes_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions11seconds_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions11seconds_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['microseconds_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'_ZN5doris18TimestampFunctions10micros_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
@@ -1199,59 +1199,59 @@ visible_functions = [
[['years_add'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9years_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['years_sub'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9years_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_add', 'add_months'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions10months_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_sub'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions10months_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_add'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9weeks_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_sub'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9weeks_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_add', 'date_add', 'adddate'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions8days_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_sub', 'date_sub', 'subdate'], 'DATEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions8days_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_add'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9hours_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_sub'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions9hours_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_add'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions11minutes_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_sub'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions11minutes_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_add'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions11seconds_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_sub'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions11seconds_subEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['microseconds_add'], 'DATETIMEV2', ['DATEV2', 'INT'],
'_ZN5doris18TimestampFunctions10micros_addEPN9doris_udf'
'15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
@@ -1263,45 +1263,45 @@ visible_functions = [
[['datediff'], 'INT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions9date_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions9time_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['datediff'], 'INT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions9date_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions9time_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['datediff'], 'INT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions9date_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['timediff'], 'TIMEV2', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions9time_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['datediff'], 'INT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions9date_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['timediff'], 'TIMEV2', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions9time_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['datediff'], 'INT', ['DATETIMEV2', 'DATETIME'],
'_ZN5doris18TimestampFunctions9date_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATETIME'],
'_ZN5doris18TimestampFunctions9time_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['datediff'], 'INT', ['DATEV2', 'DATETIME'],
'_ZN5doris18TimestampFunctions9date_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['timediff'], 'TIMEV2', ['DATEV2', 'DATETIME'],
'_ZN5doris18TimestampFunctions9time_diffEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValES6_', '', '', 'vec', ''],
[['date_format'], 'VARCHAR', ['DATETIMEV2', 'VARCHAR'],
'_ZN5doris18TimestampFunctions11date_formatEPN9doris_udf'
@@ -1323,17 +1323,17 @@ visible_functions = [
[['dayname'], 'VARCHAR', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions8day_nameEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['monthname'], 'VARCHAR', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions10month_nameEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['dayname'], 'VARCHAR', ['DATEV2'],
'_ZN5doris18TimestampFunctions8day_nameEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['monthname'], 'VARCHAR', ['DATEV2'],
'_ZN5doris18TimestampFunctions10month_nameEPN9doris_udf'
- '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec',
'ALWAYS_NULLABLE'],
+ '15FunctionContextERKNS1_11DateTimeV2ValE', '', '', 'vec', ''],
[['convert_tz'], 'DATETIMEV2', ['DATETIMEV2', 'VARCHAR', 'VARCHAR'],
'_ZN5doris18TimestampFunctions10convert_tzEPN9doris_udf15FunctionContextERKNS1_11DateV2ValERKNS1_9StringValES9_',
@@ -1349,91 +1349,90 @@ visible_functions = [
[['years_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions10years_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions11months_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions10weeks_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions9days_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions10hours_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions12minutes_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions12seconds_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['years_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions10years_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions11months_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions10weeks_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions9days_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions10hours_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions12minutes_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'],
'_ZN5doris18TimestampFunctions12seconds_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['years_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions10years_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions11months_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions10weeks_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions9days_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions10hours_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions12minutes_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions12seconds_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
-
+ '', '', 'vec', ''],
[['years_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions10years_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['months_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions11months_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['weeks_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions10weeks_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['days_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions9days_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['hours_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions10hours_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['minutes_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions12minutes_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['seconds_diff'], 'BIGINT', ['DATEV2', 'DATEV2'],
'_ZN5doris18TimestampFunctions12seconds_diffEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
+ '', '', 'vec', ''],
[['year_floor'], 'DATETIMEV2', ['DATETIMEV2'],
'_ZN5doris18TimestampFunctions10year_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
@@ -1700,54 +1699,6 @@ visible_functions = [
[['day_ceil'], 'DATEV2', ['DATEV2', 'INT', 'DATEV2'],
'_ZN5doris18TimestampFunctions8day_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValES6_',
'', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_floor'], 'DATETIMEV2', ['DATEV2'],
-
'_ZN5doris18TimestampFunctions12minute_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_floor'], 'DATETIMEV2', ['DATEV2', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions12minute_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_floor'], 'DATETIMEV2', ['DATEV2', 'INT'],
-
'_ZN5doris18TimestampFunctions12minute_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_floor'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions12minute_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_ceil'], 'DATETIMEV2', ['DATEV2'],
-
'_ZN5doris18TimestampFunctions11minute_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_ceil'], 'DATETIMEV2', ['DATEV2', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions11minute_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_ceil'], 'DATETIMEV2', ['DATEV2', 'INT'],
-
'_ZN5doris18TimestampFunctions11minute_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['minute_ceil'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions11minute_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_floor'], 'DATETIMEV2', ['DATEV2'],
-
'_ZN5doris18TimestampFunctions12second_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_floor'], 'DATETIMEV2', ['DATEV2', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions12second_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_floor'], 'DATETIMEV2', ['DATEV2', 'INT'],
-
'_ZN5doris18TimestampFunctions12second_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_floor'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions12second_floorEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_ceil'], 'DATETIMEV2', ['DATEV2'],
-
'_ZN5doris18TimestampFunctions11second_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_ceil'], 'DATETIMEV2', ['DATEV2', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions11second_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_ceil'], 'DATETIMEV2', ['DATEV2', 'INT'],
-
'_ZN5doris18TimestampFunctions11second_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValE',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
- [['second_ceil'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
-
'_ZN5doris18TimestampFunctions11second_ceilEPN9doris_udf15FunctionContextERKNS1_11DateTimeV2ValERKNS1_6IntValES6_',
- '', '', 'vec', 'ALWAYS_NULLABLE'],
# Math builtin functions
[['pi'], 'DOUBLE', [],
diff --git
a/regression-test/data/query_p0/sql_functions/math_functions/test_round.out
b/regression-test/data/query_p0/sql_functions/math_functions/test_round.out
index 1c672c02f4..b29860bfc5 100644
--- a/regression-test/data/query_p0/sql_functions/math_functions/test_round.out
+++ b/regression-test/data/query_p0/sql_functions/math_functions/test_round.out
@@ -5,6 +5,18 @@
-- !select --
10.12
+-- !select --
+16.000 16.00000 16.00000
+
+-- !select --
+16.000 16.00000 16.00000
+
+-- !select --
+17.000 17.00000 17.00000
+
+-- !select --
+16.000 16.00000 16.00000
+
-- !select --
16.030 16.03000 16.03000
diff --git
a/regression-test/suites/query_p0/sql_functions/math_functions/test_round.groovy
b/regression-test/suites/query_p0/sql_functions/math_functions/test_round.groovy
index a79417b885..206601f670 100644
---
a/regression-test/suites/query_p0/sql_functions/math_functions/test_round.groovy
+++
b/regression-test/suites/query_p0/sql_functions/math_functions/test_round.groovy
@@ -32,6 +32,10 @@ suite("test_round") {
PROPERTIES ( "replication_num" = "1" ); """
sql """ insert into `${tableName}` values(16.025, 16.025, 16.025); """
+ qt_select """ SELECT round(col1), round(col2), round(col3) FROM
`${tableName}`; """
+ qt_select """ SELECT floor(col1), floor(col2), floor(col3) FROM
`${tableName}`; """
+ qt_select """ SELECT ceil(col1), ceil(col2), ceil(col3) FROM
`${tableName}`; """
+ qt_select """ SELECT round_bankers(col1), round_bankers(col2),
round_bankers(col3) FROM `${tableName}`; """
qt_select """ SELECT round(col1, 2), round(col2, 2), round(col3, 2) FROM
`${tableName}`; """
qt_select """ SELECT floor(col1, 2), floor(col2, 2), floor(col3, 2) FROM
`${tableName}`; """
qt_select """ SELECT ceil(col1, 2), ceil(col2, 2), ceil(col3, 2) FROM
`${tableName}`; """
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
