zhiqiang-hhhh commented on code in PR #32746:
URL: https://github.com/apache/doris/pull/32746#discussion_r1546156129
##########
be/src/vec/functions/round.h:
##########
@@ -446,6 +479,179 @@ struct Dispatcher {
return nullptr;
}
}
+
+ // NOTE: This function is only tested for truncate
+ // DO NOT USE THIS METHOD FOR OTHER ROUNDING BASED FUNCTION UNTIL YOU KNOW
EXACTLY WHAT YOU ARE DOING !!!
+ static ColumnPtr apply_vec_vec(const IColumn* col_general, const IColumn*
col_scale) {
+ if constexpr (rounding_mode != RoundingMode::Trunc) {
+ throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
+ "Using column as scale is only supported
for function truncate");
+ }
+
+ const ColumnInt32& col_scale_i32 = assert_cast<const
ColumnInt32&>(*col_scale);
+ const size_t input_row_count = col_scale_i32.size();
+ for (size_t i = 0; i < input_row_count; ++i) {
+ const Int32 scale_arg = col_scale_i32.get_data()[i];
+ if (scale_arg > std::numeric_limits<Int16>::max() ||
+ scale_arg < std::numeric_limits<Int16>::min()) {
+ throw doris::Exception(ErrorCode::OUT_OF_BOUND,
+ "Scale argument for function is out of
bound: {}",
+ scale_arg);
+ }
+ }
+
+ if constexpr (IsNumber<T>) {
+ const auto* col = assert_cast<const ColumnVector<T>*>(col_general);
+ auto col_res = ColumnVector<T>::create();
+ typename ColumnVector<T>::Container& vec_res = col_res->get_data();
+ vec_res.resize(input_row_count);
+
+ for (size_t i = 0; i < input_row_count; ++i) {
+ const Int32 scale_arg = col_scale_i32.get_data()[i];
+ if (scale_arg == 0) {
+ size_t scale = 1;
+
FunctionRoundingImpl<ScaleMode::Zero>::apply(col->get_data()[i], scale,
+ vec_res[i]);
+ } else if (scale_arg > 0) {
+ size_t scale = int_exp10(scale_arg);
+
FunctionRoundingImpl<ScaleMode::Positive>::apply(col->get_data()[i], scale,
+
vec_res[i]);
+ } else {
+ size_t scale = int_exp10(-scale_arg);
+
FunctionRoundingImpl<ScaleMode::Negative>::apply(col->get_data()[i], scale,
+
vec_res[i]);
+ }
+ }
+ return col_res;
+ } else if constexpr (IsDecimalNumber<T>) {
+ const auto* decimal_col = assert_cast<const
ColumnDecimal<T>*>(col_general);
+
+ // For truncate, ALWAYS use SAME scale with source Decimal column
+ const Int32 input_scale = decimal_col->get_scale();
+ auto col_res = ColumnDecimal<T>::create(input_row_count,
input_scale);
+
+ for (size_t i = 0; i < input_row_count; ++i) {
+ DecimalRoundingImpl<T, rounding_mode,
tie_breaking_mode>::apply(
+ decimal_col->get_element(i).value, input_scale,
+ col_res->get_element(i).value,
col_scale_i32.get_data()[i]);
+ }
+
+ for (size_t i = 0; i < input_row_count; ++i) {
+ // For truncate(ColumnDecimal, ColumnInt32), we should always
have same scale with source Decimal column
+ // So we need this check to make sure the result have correct
digits count
+ //
+ // Case 0: scale_arg <= -(integer part digits count)
+ // do nothing, because result is 0
+ // Case 1: scale_arg <= 0 && scale_arg > -(integer part digits
count)
+ // decimal parts has been erased, so add them back by
multiply 10^(scale_arg)
+ // Case 2: scale_arg > 0 && scale_arg < decimal part digits
count
+ // decimal part now has scale_arg digits, so multiply
10^(input_scale - scal_arg)
+ // Case 3: scale_arg >= input_scale
+ // do nothing
+ const Int32 scale_arg = col_scale_i32.get_data()[i];
+ if (scale_arg <= 0) {
+ col_res->get_element(i).value *= int_exp10(input_scale);
+ } else if (scale_arg > 0 && scale_arg < input_scale) {
+ col_res->get_element(i).value *= int_exp10(input_scale -
scale_arg);
+ }
+ }
+
+ return col_res;
+ } else {
+ LOG(FATAL) << "__builtin_unreachable";
+ __builtin_unreachable();
+ return nullptr;
+ }
+ }
+
+ // NOTE: This function is only tested for truncate
+ // DO NOT USE THIS METHOD FOR OTHER ROUNDING BASED FUNCTION UNTIL YOU KNOW
EXACTLY WHAT YOU ARE DOING !!! only test for truncate
+ static ColumnPtr apply_const_vec(const ColumnConst* const_col_general,
+ const IColumn* col_scale) {
+ if constexpr (rounding_mode != RoundingMode::Trunc) {
+ throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
+ "Using column as scale is only supported
for function truncate");
+ }
+
+ const ColumnInt32& col_scale_i32 = assert_cast<const
ColumnInt32&>(*col_scale);
+ const size_t input_rows_count = col_scale->size();
+
+ for (size_t i = 0; i < input_rows_count; ++i) {
+ const Int32 scale_arg = col_scale_i32.get_data()[i];
+
+ if (scale_arg > std::numeric_limits<Int16>::max() ||
+ scale_arg < std::numeric_limits<Int16>::min()) {
+ throw doris::Exception(ErrorCode::OUT_OF_BOUND,
Review Comment:
make sense
##########
be/src/vec/functions/function_truncate.h:
##########
@@ -0,0 +1,246 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <cstddef>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "common/exception.h"
+#include "common/status.h"
+#include "olap/olap_common.h"
+#include "round.h"
+#include "vec/columns/column.h"
+#include "vec/columns/column_const.h"
+#include "vec/columns/column_decimal.h"
+#include "vec/columns/column_vector.h"
+#include "vec/common/assert_cast.h"
+#include "vec/core/call_on_type_index.h"
+#include "vec/core/field.h"
+#include "vec/core/types.h"
+#include "vec/data_types/data_type.h"
+#include "vec/data_types/data_type_decimal.h"
+#include "vec/data_types/data_type_number.h"
+
+namespace doris::vectorized {
+
+struct TruncateFloatOneArgImpl {
+ static constexpr auto name = "truncate";
+ static DataTypes get_variadic_argument_types() { return
{std::make_shared<DataTypeFloat64>()}; }
+};
+
+struct TruncateFloatTwoArgImpl {
+ static constexpr auto name = "truncate";
+ static DataTypes get_variadic_argument_types() {
+ return {std::make_shared<DataTypeFloat64>(),
std::make_shared<DataTypeInt32>()};
+ }
+};
+
+struct TruncateDecimalOneArgImpl {
+ static constexpr auto name = "truncate";
+ static DataTypes get_variadic_argument_types() {
+ // All Decimal types are named Decimal, and real scale will be passed
as type argument for execute function
+ // So we can just register Decimal32 here
+ return {std::make_shared<DataTypeDecimal<Decimal32>>(9, 0)};
+ }
+};
+
+struct TruncateDecimalTwoArgImpl {
+ static constexpr auto name = "truncate";
+ static DataTypes get_variadic_argument_types() {
+ return {std::make_shared<DataTypeDecimal<Decimal32>>(9, 0),
+ std::make_shared<DataTypeInt32>()};
+ }
+};
+
+template <typename Impl>
+class FunctionTruncate : public FunctionRounding<Impl, RoundingMode::Trunc,
TieBreakingMode::Auto> {
+public:
+ static FunctionPtr create() { return std::make_shared<FunctionTruncate>();
}
+
+ ColumnNumbers get_arguments_that_are_always_constant() const override {
return {}; }
+ // SELECT number, truncate(123.345, 1) FROM number("numbers"="10")
+ // should NOT behave like two column arguments, so we can not use const
column default implementation
+ bool use_default_implementation_for_constants() const override { return
false; }
+
+ Status execute_impl(FunctionContext* context, Block& block, const
ColumnNumbers& arguments,
+ size_t result, size_t input_rows_count) const override
{
+ const ColumnWithTypeAndName& column_general =
block.get_by_position(arguments[0]);
+ ColumnPtr res;
+
+ // potential argument types:
+ // 0. truncate(ColumnConst, ColumnConst)
+ // 1. truncate(Column), truncate(Column, ColumnConst)
+ // 2. truncate(Column, Column)
+ // 3. truncate(ColumnConst, Column)
+
+ if (arguments.size() == 2 &&
is_column_const(*block.get_by_position(arguments[0]).column) &&
+ is_column_const(*block.get_by_position(arguments[1]).column)) {
+ // truncate(ColumnConst, ColumnConst)
+ auto col_general = assert_cast<const
ColumnConst&>(*column_general.column)
+ .get_data_column()
Review Comment:
make sense
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
