be/src/exprs/function/cast/cast_to_int.h

Source
// 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.

#pragma once

#include <type_traits>

#include "common/status.h"
#include "core/data_type/data_type_decimal.h"
#include "core/data_type/data_type_number.h"
#include "core/data_type/primitive_type.h"
#include "exprs/function/cast/cast_to_basic_number_common.h"

namespace doris {

// Types that can be cast to int: string, bool, int, float, double, decimal, date, datetime and time.
// It's not supported to cast date to tinyint and smallint, because it will definitely overflow.
// It's not supported to cast datetime to tinyint and smallint, because it will definitely overflow.
// Casting from string and decimal types are handled in `cast_to_basic_number_common.h`.

// may overflow if:
// 1. from wider int to narrower int
// 2. from float/double to int
// 3. from time to tinyint, smallint and int
template <typename FromDataType, typename ToDataType>
constexpr bool CastToIntMayOverflow =
        (IsDataTypeInt<FromDataType> &&
         sizeof(typename FromDataType::FieldType) > sizeof(typename ToDataType::FieldType)) ||
        IsDataTypeFloat<FromDataType> ||
        (std::is_same_v<FromDataType, DataTypeTimeV2> &&
         (std::is_same_v<ToDataType, DataTypeInt32> || std::is_same_v<ToDataType, DataTypeInt16> ||
          std::is_same_v<ToDataType, DataTypeInt8>));

// from number types and timev2 type to integer types which this cast may overflow -> result type is always nullable.
template <CastModeType CastMode, typename FromDataType, typename ToDataType>
    requires(IsDataTypeInt<ToDataType> &&
             (IsDataTypeNumber<FromDataType> || std::is_same_v<FromDataType, DataTypeTimeV2>) &&
             CastToIntMayOverflow<FromDataType, ToDataType>)
class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
public:
    Status execute_impl(RuntimeState* /*state*/, const ColumnWithTypeAndName& source_column,
                        ColumnWithTypeAndName& target_column, size_t input_rows_count,
                        const NullMap::value_type* parent_null_map = nullptr) const override {
        const auto* col_from =
                check_and_get_column<typename FromDataType::ColumnType>(source_column.column.get());
        if (!col_from) {
            return Status::InternalError(fmt::format("Column type mismatch: expected {}, got {}",
                                                     type_to_string(FromDataType::PType),
                                                     source_column.column->get_name()));
        }
        auto col_to = ToDataType::ColumnType::create(input_rows_count);
        const auto& vec_from = col_from->get_data();
        auto& vec_to = col_to->get_data();
        ColumnBool::MutablePtr col_null_map_to = ColumnBool::create(input_rows_count, 0);
        NullMap::value_type* vec_null_map_to = col_null_map_to->get_data().data();

        CastParameters params;
        params.is_strict = (CastMode == CastModeType::StrictMode);
        for (size_t i = 0; i < input_rows_count; ++i) {
            // The source value of a row marked as null by the input null map is a hidden
            // payload and has no SQL semantics, so it must not be checked.
            if (parent_null_map && parent_null_map[i]) {
                continue;
            }
            if constexpr (IsDataTypeInt<FromDataType>) {
                // although always nullable output, but only set null when overflow in non-strict mode.
                // in strict mode, just raise error on overflow.
                if (!CastToInt::from_int(vec_from[i], vec_to[i], params)) {
                    if constexpr (CastMode == CastModeType::NonStrictMode) {
                        vec_null_map_to[i] = 1;
                        continue;
                    } else {
                        return params.status;
                    }
                }
            } else if constexpr (IsDataTypeFloat<FromDataType>) {
                if (!CastToInt::from_float(vec_from[i], vec_to[i], params)) {
                    if constexpr (CastMode == CastModeType::NonStrictMode) {
                        vec_null_map_to[i] = 1;
                        continue;
                    } else {
                        return params.status;
                    }
                }
            } else if constexpr (std::is_same_v<FromDataType, DataTypeTimeV2>) {
                if (!CastToInt::from_time(vec_from[i], vec_to[i], params)) {
                    if constexpr (CastMode == CastModeType::NonStrictMode) {
                        vec_null_map_to[i] = 1;
                        continue;
                    } else {
                        return params.status;
                    }
                }
            } else {
                return Status::InternalError(fmt::format("Unsupported cast from {} to {}",
                                                         type_to_string(FromDataType::PType),
                                                         type_to_string(ToDataType::PType)));
            }
        }
        target_column.column =
                ColumnNullable::create(std::move(col_to), std::move(col_null_map_to));

        return Status::OK();
    }
};

/// cast to int, will not overflow and no nullable output:
/// 1. from bool;
/// 2. from narrow int to wider int
/// 3. from time to bigint and largeint
template <CastModeType CastMode, typename FromDataType, typename ToDataType>
    requires(IsDataTypeInt<ToDataType> &&
             (IsDataTypeNumber<FromDataType> || std::is_same_v<FromDataType, DataTypeTimeV2>) &&
             !CastToIntMayOverflow<FromDataType, ToDataType>)
class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
public:
    Status execute_impl(RuntimeState* state, const ColumnWithTypeAndName& source_column,
                        ColumnWithTypeAndName& target_column, size_t input_rows_count,
                        const NullMap::value_type* parent_null_map = nullptr) const override {
        return static_cast_no_overflow<FromDataType, ToDataType>(
                state, source_column, target_column, input_rows_count, parent_null_map);
    }
};

// cast decimal to integer. always use overflow check to decide nullable
template <CastModeType CastMode, typename FromDataType, typename ToDataType>
    requires(IsDataTypeInt<ToDataType> && IsDataTypeDecimal<FromDataType>)
class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
public:
    Status execute_impl(RuntimeState* /*state*/, const ColumnWithTypeAndName& source_column,
                        ColumnWithTypeAndName& target_column, size_t input_rows_count,
                        const NullMap::value_type* parent_null_map = nullptr) const override {
        using ToFieldType = typename ToDataType::FieldType;

        const ColumnWithTypeAndName& named_from = source_column;
        const auto* col_from =
                check_and_get_column<typename FromDataType::ColumnType>(named_from.column.get());
        if (!col_from) {
            return Status::InternalError(fmt::format("Column type mismatch: expected {}, got {}",
                                                     type_to_string(FromDataType::PType),
                                                     named_from.column->get_name()));
        }
        const auto& from_decimal_type = assert_cast<const FromDataType&>(*named_from.type);
        UInt32 from_precision = from_decimal_type.get_precision();
        UInt32 from_scale = from_decimal_type.get_scale();

        // may overflow if integer part of decimal is larger than to_max_digits
        // in strict mode we also decide nullable on this.
        constexpr UInt32 to_max_digits = NumberTraits::max_ascii_len<ToFieldType>();
        bool overflow_and_nullable = (from_precision - from_scale) >= to_max_digits;
        // only in non-strict mode and may overflow, we set nullable
        bool set_nullable = (CastMode == CastModeType::NonStrictMode) && overflow_and_nullable;

        auto col_to = ToDataType::ColumnType::create(input_rows_count);
        const auto& vec_from = col_from->get_data();
        const auto* vec_from_data = vec_from.data();
        auto& vec_to = col_to->get_data();
        auto* vec_to_data = vec_to.data();

        ColumnUInt8::MutablePtr col_null_map_to;
        NullMap::value_type* null_map_data = nullptr;
        if (overflow_and_nullable) {
            col_null_map_to = ColumnUInt8::create(input_rows_count, 0);
            null_map_data = col_null_map_to->get_data().data();
        }

        CastParameters params;
        params.is_strict = (CastMode == CastModeType::StrictMode);
        size_t size = vec_from.size();
        for (size_t i = 0; i < size; i++) {
            // Skip hidden payload of rows marked as null by the input null map.
            if (parent_null_map && parent_null_map[i]) {
                continue;
            }
            if (!CastToInt::from_decimal<typename FromDataType::FieldType,
                                         typename ToDataType::FieldType>(
                        vec_from_data[i], from_precision, from_scale, vec_to_data[i], params)) {
                if (set_nullable) {
                    null_map_data[i] = 1;
                } else {
                    return params.status;
                }
            }
        }

        if (overflow_and_nullable) {
            target_column.column =
                    ColumnNullable::create(std::move(col_to), std::move(col_null_map_to));
        } else {
            target_column.column = std::move(col_to);
        }
        return Status::OK();
    }
};

template <typename T>
constexpr static bool int_allow_cast_from_date =
        std::is_same_v<T, DataTypeInt32> || std::is_same_v<T, DataTypeInt64> ||
        std::is_same_v<T, DataTypeInt128>;

template <typename T>
constexpr static bool int_allow_cast_from_datetime =
        std::is_same_v<T, DataTypeInt64> || std::is_same_v<T, DataTypeInt128>;

// cast from date and datetime to int
template <CastModeType CastMode, typename FromDataType, typename ToDataType>
    requires(((IsDateType<FromDataType> ||
               IsDateV2Type<FromDataType>)&&int_allow_cast_from_date<ToDataType>) ||
             ((IsDateTimeType<FromDataType> || IsDateTimeV2Type<FromDataType> ||
               std::is_same_v<FromDataType,
                              DataTypeTimeStampNs>)&&int_allow_cast_from_datetime<ToDataType>))
class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
public:
    Status execute_impl(RuntimeState* state, const ColumnWithTypeAndName& source_column,
                        ColumnWithTypeAndName& target_column, size_t input_rows_count,
                        const NullMap::value_type* parent_null_map = nullptr) const override {
        return static_cast_no_overflow<FromDataType, ToDataType>(
                state, source_column, target_column, input_rows_count, parent_null_map);
    }
};
} // namespace doris

Coverage Report

Created: 2026-10-28 22:39