be/src/exprs/function/datetime_errors.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 <string>
#include <string_view>

#include "common/exception.h"
#include "common/status.h"
#include "core/binary_cast.hpp"
#include "core/types.h"
#include "core/value/timestamptz_value.h"

namespace doris {
// Convert a native datelike value to printable string using DateValueType::to_string
// Note: DateValueType must support to_string(char*) -> char*
//       NativeT is the corresponding FieldType of the DataType
template <typename DateValueType>
inline std::string datelike_to_string(DateValueType value) {
    char buf[40];
    char* end = value.to_string(buf);
    // minus 1 to skip trailing '\0'
    return std::string(buf, end - 1);
}

// Specialization for TimestampTzValue: output UTC time for error messages
template <>
inline std::string datelike_to_string<TimestampTzValue>(TimestampTzValue native) {
    // Use UTC timezone for error messages
    return native.to_string(cctz::utc_time_zone());
}

// Throw for operations with one datelike argument
template <typename DateValueType>
[[noreturn]] inline void throw_out_of_bound_one_date(const char* op, DateValueType arg0) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {} out of range", op,
                    datelike_to_string<DateValueType>(arg0));
}

// Throw for operations with a datelike and an integer (e.g. period)
template <typename DateValueType>
[[noreturn]] inline void throw_out_of_bound_date_int(const char* op, DateValueType arg0,
                                                     Int64 delta) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {}, {} out of range", op,
                    datelike_to_string<DateValueType>(arg0), delta);
}

// Throw for operations with a datelike and a string interval(e.g., date_add(date, interval '-1 2:3:4' day_second))
template <typename DateValueType>
[[noreturn]] inline void throw_out_of_bound_date_string(const char* op, DateValueType arg0,
                                                        std::string_view delta) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {}, {} out of range", op,
                    datelike_to_string<DateValueType>(arg0), delta);
}

// Throw for operations with a single integer argument (e.g., from_days daynr)
[[noreturn]] inline void throw_out_of_bound_int(const char* op, int64_t value) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {} out of range", op, value);
}

// Throw for operations with two integer arguments (e.g., makedate(year, day))
[[noreturn]] inline void throw_out_of_bound_two_ints(const char* op, int64_t a, int64_t b) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {}, {} out of range", op, a, b);
}

// for convert_tz
template <typename DateValueType>
[[noreturn]] inline void throw_out_of_bound_convert_tz(DateValueType arg0,
                                                       std::string_view from_name,
                                                       std::string_view to_name) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Cannot convert {} from {} to {}",
                    datelike_to_string<DateValueType>(arg0), from_name, to_name);
}

// Throw for operations with a datelike, an integer and an origin datelike
// (e.g. time_round(datetime, period, origin))
template <typename DateValueType>
[[noreturn]] inline void throw_out_of_bound_int_date(const char* op, DateValueType arg0,
                                                     Int32 delta, DateValueType origin) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {}, {}, {} out of range", op,
                    datelike_to_string<DateValueType>(arg0), delta,
                    datelike_to_string<DateValueType>(origin));
}

// Throw for operations with two datelike arguments
// (e.g. time_round(datetime, origin))
template <typename DateValueType>
[[noreturn]] inline void throw_out_of_bound_date_date(const char* op, DateValueType arg0,
                                                      DateValueType arg1) {
    throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {}, {} out of range", op,
                    datelike_to_string<DateValueType>(arg0),
                    datelike_to_string<DateValueType>(arg1));
}

// Throw for operations with an invalid string argument (e.g., from_iso8601_date)
[[noreturn]] inline void throw_invalid_string(const char* op, std::string_view s) {
    throw Exception(ErrorCode::INVALID_ARGUMENT, "Operation {} of {} is invalid", op, s);
}

// Throw for operations with two invalid string arguments (e.g., unix_timestamp with format)
[[noreturn]] inline void throw_invalid_strings(const char* op, std::string_view s0,
                                               std::string_view s1) {
    throw Exception(ErrorCode::INVALID_ARGUMENT, "Operation {} of {}, {} is invalid", op, s0, s1);
}

// Helper to get time unit name for error messages
constexpr const char* get_time_unit_name(TimeUnit unit) {
    switch (unit) {
    case TimeUnit::YEAR:
        return "year_add";
    case TimeUnit::QUARTER:
        return "quarter_add";
    case TimeUnit::MONTH:
        return "month_add";
    case TimeUnit::WEEK:
        return "week_add";
    case TimeUnit::DAY:
        return "day_add";
    case TimeUnit::HOUR:
        return "hour_add";
    case TimeUnit::MINUTE:
        return "minute_add";
    case TimeUnit::SECOND:
        return "second_add";
    case TimeUnit::MILLISECOND:
        return "millisecond_add";
    case TimeUnit::MICROSECOND:
        return "microsecond_add";
    case TimeUnit::YEAR_MONTH:
        return "year_month_add";
    case TimeUnit::DAY_HOUR:
        return "day_hour_add";
    case TimeUnit::DAY_MINUTE:
        return "day_minute_add";
    case TimeUnit::DAY_SECOND:
        return "day_second_add";
    case TimeUnit::DAY_MICROSECOND:
        return "day_microsecond_add";
    case TimeUnit::HOUR_MINUTE:
        return "hour_minute_add";
    case TimeUnit::HOUR_SECOND:
        return "hour_second_add";
    case TimeUnit::HOUR_MICROSECOND:
        return "hour_microsecond_add";
    case TimeUnit::MINUTE_SECOND:
        return "minute_second_add";
    case TimeUnit::MINUTE_MICROSECOND:
        return "minute_microsecond_add";
    case TimeUnit::SECOND_MICROSECOND:
        return "second_microsecond_add";
    default:
        return "date_add";
    }
}
} // namespace doris

Coverage Report

Created: 2026-09-24 12:00