This is an automated email from the ASF dual-hosted git repository.
gabriellee pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new ba026b6e99 [datev2](function) make function nullable
DEPEND_ON_ARGUMENT (#16159)
ba026b6e99 is described below
commit ba026b6e990042494363f1acca23c0c7e96a03da
Author: Gabriel <[email protected]>
AuthorDate: Wed Feb 1 13:57:43 2023 +0800
[datev2](function) make function nullable DEPEND_ON_ARGUMENT (#16159)
---
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 +-
be/src/vec/functions/function_timestamp.cpp | 369 ++++++++++++++++-----
gensrc/script/doris_builtins_functions.py | 248 +++++++-------
7 files changed, 773 insertions(+), 300 deletions(-)
diff --git a/be/src/vec/functions/date_time_transforms.h
b/be/src/vec/functions/date_time_transforms.h
index 05c9d498ab..17de07fd4e 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 {
@@ -255,6 +256,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>
@@ -302,6 +321,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>
@@ -324,21 +354,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 dac7700fb6..85e1f02394 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..ff793358c9 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 valid = 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], valid);
+ DCHECK(valid);
+ }
+ }
// 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 valid = true;
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i], valid);
+ DCHECK(valid);
+ }
+ }
// 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 valid = true;
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from[i], delta, valid);
+ DCHECK(valid);
+ }
+ }
// 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 valid = true;
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(vec_from[i], delta, valid);
+ DCHECK(valid);
+ }
+ }
// 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 valid = true;
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(from, delta.get_int(i), valid);
+ DCHECK(valid);
+ }
+ }
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 valid = true;
+
+ for (size_t i = 0; i < size; ++i) {
+ vec_to[i] = Transform::execute(from, delta[i], valid);
+ DCHECK(valid);
+ }
+ }
};
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_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/gensrc/script/doris_builtins_functions.py
b/gensrc/script/doris_builtins_functions.py
index 91ee009ccb..080f01b2ac 100644
--- a/gensrc/script/doris_builtins_functions.py
+++ b/gensrc/script/doris_builtins_functions.py
@@ -544,8 +544,8 @@ visible_functions = [
[['unix_timestamp'], 'INT', [], 'ALWAYS_NOT_NULLABLE'],
[['unix_timestamp'], 'INT', ['DATETIME'], 'ALWAYS_NULLABLE'],
[['unix_timestamp'], 'INT', ['DATE'], 'ALWAYS_NULLABLE'],
- [['unix_timestamp'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['unix_timestamp'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['unix_timestamp'], 'INT', ['DATETIMEV2'], ''],
+ [['unix_timestamp'], 'INT', ['DATEV2'], ''],
[['unix_timestamp'], 'INT', ['VARCHAR', 'VARCHAR'], 'ALWAYS_NULLABLE'],
[['unix_timestamp'], 'INT', ['STRING', 'STRING'], 'ALWAYS_NULLABLE'],
[['from_unixtime'], 'VARCHAR', ['INT'], 'ALWAYS_NULLABLE'],
@@ -561,10 +561,10 @@ visible_functions = [
[['from_days'], 'DATE', ['INT'], 'ALWAYS_NULLABLE'],
[['last_day'], 'DATE', ['DATETIME'], 'ALWAYS_NULLABLE'],
[['last_day'], 'DATE', ['DATE'], 'ALWAYS_NULLABLE'],
- [['last_day'], 'DATEV2', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['last_day'], 'DATEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['to_monday'], 'DATEV2', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['to_monday'], 'DATEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['last_day'], 'DATEV2', ['DATETIMEV2'], ''],
+ [['last_day'], 'DATEV2', ['DATEV2'], ''],
+ [['to_monday'], 'DATEV2', ['DATETIMEV2'], ''],
+ [['to_monday'], 'DATEV2', ['DATEV2'], ''],
[['to_monday'], 'DATE', ['DATETIME'], 'ALWAYS_NULLABLE'],
[['to_monday'], 'DATE', ['DATE'], 'ALWAYS_NULLABLE'],
[['to_days'], 'INT', ['DATE'], 'ALWAYS_NULLABLE'],
@@ -686,103 +686,97 @@ visible_functions = [
[['second_ceil'], 'DATETIME', ['DATETIME', 'INT'], 'ALWAYS_NULLABLE'],
[['second_ceil'], 'DATETIME', ['DATETIME', 'INT', 'DATETIME'],
'ALWAYS_NULLABLE'],
- [['timestamp'], 'DATETIMEV2', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
-
- [['to_days'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
-
- [['year'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['month'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['quarter'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['dayofweek'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['weekday'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['day', 'dayofmonth'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['dayofyear'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['weekofyear'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['yearweek'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['yearweek'], 'INT', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['week'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['week'], 'INT', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['hour'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['minute'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['second'], 'INT', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
-
- [['year'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['month'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['quarter'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['dayofweek'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['weekday'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['day', 'dayofmonth'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['dayofyear'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['weekofyear'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['yearweek'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['yearweek'], 'INT', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['week'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['week'], 'INT', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['hour'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['minute'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['second'], 'INT', ['DATEV2'], 'ALWAYS_NULLABLE'],
-
- [['years_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['years_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['months_add', 'add_months'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'ALWAYS_NULLABLE'],
- [['months_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['weeks_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['weeks_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['days_add', 'date_add', 'adddate'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'ALWAYS_NULLABLE'],
- [['days_sub', 'date_sub', 'subdate'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
'ALWAYS_NULLABLE'],
- [['hours_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['hours_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['minutes_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['minutes_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['seconds_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['seconds_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['timestamp'], 'DATETIMEV2', ['DATETIMEV2'], ''],
+
+ [['to_days'], 'INT', ['DATEV2'], ''],
+
+ [['year'], 'INT', ['DATETIMEV2'], ''],
+ [['month'], 'INT', ['DATETIMEV2'], ''],
+ [['quarter'], 'INT', ['DATETIMEV2'], ''],
+ [['dayofweek'], 'INT', ['DATETIMEV2'], ''],
+ [['weekday'], 'INT', ['DATETIMEV2'], ''],
+ [['day', 'dayofmonth'], 'INT', ['DATETIMEV2'], ''],
+ [['dayofyear'], 'INT', ['DATETIMEV2'], ''],
+ [['weekofyear'], 'INT', ['DATETIMEV2'], ''],
+ [['yearweek'], 'INT', ['DATETIMEV2'], ''],
+ [['yearweek'], 'INT', ['DATETIMEV2', 'INT'], ''],
+ [['week'], 'INT', ['DATETIMEV2'], ''],
+ [['week'], 'INT', ['DATETIMEV2', 'INT'], ''],
+ [['hour'], 'INT', ['DATETIMEV2'], ''],
+ [['minute'], 'INT', ['DATETIMEV2'], ''],
+ [['second'], 'INT', ['DATETIMEV2'], ''],
+
+ [['year'], 'INT', ['DATEV2'], ''],
+ [['month'], 'INT', ['DATEV2'], ''],
+ [['quarter'], 'INT', ['DATEV2'], ''],
+ [['dayofweek'], 'INT', ['DATEV2'], ''],
+ [['weekday'], 'INT', ['DATEV2'], ''],
+ [['day', 'dayofmonth'], 'INT', ['DATEV2'], ''],
+ [['dayofyear'], 'INT', ['DATEV2'], ''],
+ [['weekofyear'], 'INT', ['DATEV2'], ''],
+ [['yearweek'], 'INT', ['DATEV2'], ''],
+ [['yearweek'], 'INT', ['DATEV2', 'INT'], ''],
+ [['week'], 'INT', ['DATEV2'], ''],
+ [['week'], 'INT', ['DATEV2', 'INT'], ''],
+ [['hour'], 'INT', ['DATEV2'], ''],
+ [['minute'], 'INT', ['DATEV2'], ''],
+ [['second'], 'INT', ['DATEV2'], ''],
+
+ [['years_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['years_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['months_add', 'add_months'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['months_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['weeks_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['weeks_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['days_add', 'date_add', 'adddate'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
''],
+ [['days_sub', 'date_sub', 'subdate'], 'DATETIMEV2', ['DATETIMEV2', 'INT'],
''],
+ [['hours_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['hours_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['minutes_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['minutes_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['seconds_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
+ [['seconds_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
[['microseconds_add'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
[['microseconds_sub'], 'DATETIMEV2', ['DATETIMEV2', 'INT'], ''],
- [['years_add'], 'DATEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['years_sub'], 'DATEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['months_add', 'add_months'], 'DATEV2', ['DATEV2', 'INT'],
'ALWAYS_NULLABLE'],
- [['months_sub'], 'DATEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['weeks_add'], 'DATEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['weeks_sub'], 'DATEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['days_add', 'date_add', 'adddate'], 'DATEV2', ['DATEV2', 'INT'],
'ALWAYS_NULLABLE'],
- [['days_sub', 'date_sub', 'subdate'], 'DATEV2', ['DATEV2', 'INT'],
'ALWAYS_NULLABLE'],
- [['hours_add'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['hours_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['minutes_add'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['minutes_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['seconds_add'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
- [['seconds_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['years_add'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['years_sub'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['months_add', 'add_months'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['months_sub'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['weeks_add'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['weeks_sub'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['days_add', 'date_add', 'adddate'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['days_sub', 'date_sub', 'subdate'], 'DATEV2', ['DATEV2', 'INT'], ''],
+ [['hours_add'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
+ [['hours_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
+ [['minutes_add'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
+ [['minutes_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
+ [['seconds_add'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
+ [['seconds_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
[['microseconds_add'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
[['microseconds_sub'], 'DATETIMEV2', ['DATEV2', 'INT'], ''],
- [['datediff'], 'INT', ['DATETIMEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
+ [['datediff'], 'INT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATETIMEV2'], ''],
- [['datediff'], 'INT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['datediff'], 'INT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATEV2'], ''],
- [['datediff'], 'INT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['timediff'], 'TIMEV2', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
+ [['datediff'], 'INT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['timediff'], 'TIMEV2', ['DATEV2', 'DATETIMEV2'], ''],
- [['datediff'], 'INT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['timediff'], 'TIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
-
- [['datediff'], 'INT', ['DATETIMEV2', 'DATETIME'], 'ALWAYS_NULLABLE'],
- [['timediff'], 'TIMEV2', ['DATETIMEV2', 'DATETIME'], 'ALWAYS_NULLABLE'],
-
- [['datediff'], 'INT', ['DATEV2', 'DATETIME'], 'ALWAYS_NULLABLE'],
- [['timediff'], 'TIMEV2', ['DATEV2', 'DATETIME'], 'ALWAYS_NULLABLE'],
+ [['datediff'], 'INT', ['DATEV2', 'DATEV2'], ''],
+ [['timediff'], 'TIMEV2', ['DATEV2', 'DATEV2'], ''],
[['date_format'], 'VARCHAR', ['DATETIMEV2', 'VARCHAR'], 'ALWAYS_NULLABLE'],
[['date_format'], 'VARCHAR', ['DATEV2', 'VARCHAR'], 'ALWAYS_NULLABLE'],
[['date', 'to_date', 'datev2', 'to_datev2'], 'DATEV2', ['DATETIMEV2'],
'ALWAYS_NULLABLE'],
- [['dayname'], 'VARCHAR', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['monthname'], 'VARCHAR', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
+ [['dayname'], 'VARCHAR', ['DATETIMEV2'], ''],
+ [['monthname'], 'VARCHAR', ['DATETIMEV2'], ''],
- [['dayname'], 'VARCHAR', ['DATEV2'], 'ALWAYS_NULLABLE'],
- [['monthname'], 'VARCHAR', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['dayname'], 'VARCHAR', ['DATEV2'], ''],
+ [['monthname'], 'VARCHAR', ['DATEV2'], ''],
[['convert_tz'], 'DATETIMEV2', ['DATETIMEV2', 'VARCHAR', 'VARCHAR'],
'ALWAYS_NULLABLE'],
@@ -794,29 +788,37 @@ visible_functions = [
[['minutes_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'ALWAYS_NULLABLE'],
[['seconds_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'],
'ALWAYS_NULLABLE'],
- [['years_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['months_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['weeks_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['days_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['hours_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['minutes_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
- [['seconds_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], 'ALWAYS_NULLABLE'],
-
- [['years_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['months_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['weeks_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['days_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['hours_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['minutes_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['seconds_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
-
- [['years_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['months_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['weeks_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['days_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['hours_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['minutes_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
- [['seconds_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['years_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['months_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['weeks_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['days_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['hours_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['minutes_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+ [['seconds_diff'], 'BIGINT', ['DATETIMEV2', 'DATETIMEV2'], ''],
+
+ [['years_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['months_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['weeks_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['days_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['hours_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['minutes_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+ [['seconds_diff'], 'BIGINT', ['DATEV2', 'DATETIMEV2'], ''],
+
+ [['years_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['months_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['weeks_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['days_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['hours_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['minutes_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+ [['seconds_diff'], 'BIGINT', ['DATETIMEV2', 'DATEV2'], ''],
+
+ [['years_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
+ [['months_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
+ [['weeks_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
+ [['days_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
+ [['hours_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
+ [['minutes_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
+ [['seconds_diff'], 'BIGINT', ['DATEV2', 'DATEV2'], ''],
[['year_floor'], 'DATETIMEV2', ['DATETIMEV2'], 'ALWAYS_NULLABLE'],
[['year_floor'], 'DATETIMEV2', ['DATETIMEV2', 'DATETIMEV2'],
'ALWAYS_NULLABLE'],
@@ -907,6 +909,30 @@ visible_functions = [
[['day_ceil'], 'DATEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
[['day_ceil'], 'DATEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
[['day_ceil'], 'DATEV2', ['DATEV2', 'INT', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['hour_floor'], 'DATETIMEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['hour_floor'], 'DATETIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['hour_floor'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['hour_floor'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
'ALWAYS_NULLABLE'],
+ [['hour_ceil'], 'DATETIMEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['hour_ceil'], 'DATETIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['hour_ceil'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['hour_ceil'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
'ALWAYS_NULLABLE'],
+ [['minute_floor'], 'DATETIMEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['minute_floor'], 'DATETIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['minute_floor'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['minute_floor'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
'ALWAYS_NULLABLE'],
+ [['minute_ceil'], 'DATETIMEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['minute_ceil'], 'DATETIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['minute_ceil'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['minute_ceil'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
'ALWAYS_NULLABLE'],
+ [['second_floor'], 'DATETIMEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['second_floor'], 'DATETIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['second_floor'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['second_floor'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
'ALWAYS_NULLABLE'],
+ [['second_ceil'], 'DATETIMEV2', ['DATEV2'], 'ALWAYS_NULLABLE'],
+ [['second_ceil'], 'DATETIMEV2', ['DATEV2', 'DATEV2'], 'ALWAYS_NULLABLE'],
+ [['second_ceil'], 'DATETIMEV2', ['DATEV2', 'INT'], 'ALWAYS_NULLABLE'],
+ [['second_ceil'], 'DATETIMEV2', ['DATEV2', 'INT', 'DATEV2'],
'ALWAYS_NULLABLE'],
# Math builtin functions
[['pi'], 'DOUBLE', [], 'ALWAYS_NOT_NULLABLE'],
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
