370 lines
17 KiB
C++
370 lines
17 KiB
C++
// 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.
|
|
// This file is copied from
|
|
// https://github.com/apache/impala/blob/branch-2.9.0/be/src/exprs/cast-functions.cpp
|
|
// and modified by Doris
|
|
|
|
#include "exprs/cast_functions.h"
|
|
|
|
#include <fmt/format.h>
|
|
|
|
#include <cmath>
|
|
|
|
#include "exprs/anyval_util.h"
|
|
#include "gutil/strings/numbers.h"
|
|
#include "runtime/datetime_value.h"
|
|
#include "runtime/large_int_value.h"
|
|
#include "util/array_parser.h"
|
|
#include "util/mysql_global.h"
|
|
#include "util/string_parser.hpp"
|
|
|
|
namespace doris {
|
|
|
|
void CastFunctions::init() {}
|
|
|
|
// The maximum number of characters need to represent a floating-point number (float or
|
|
// double) as a string. 24 = 17 (maximum significant digits) + 1 (decimal point) + 1 ('E')
|
|
// + 3 (exponent digits) + 2 (negative signs) (see http://stackoverflow.com/a/1701085)
|
|
const int MAX_FLOAT_CHARS = 24;
|
|
|
|
#define CAST_FUNCTION(from_type, to_type, type_name) \
|
|
to_type CastFunctions::cast_to_##type_name(FunctionContext* ctx, const from_type& val) { \
|
|
if (val.is_null) return to_type::null(); \
|
|
return to_type(val.val); \
|
|
}
|
|
|
|
CAST_FUNCTION(TinyIntVal, BooleanVal, boolean_val)
|
|
CAST_FUNCTION(SmallIntVal, BooleanVal, boolean_val)
|
|
CAST_FUNCTION(IntVal, BooleanVal, boolean_val)
|
|
CAST_FUNCTION(BigIntVal, BooleanVal, boolean_val)
|
|
CAST_FUNCTION(LargeIntVal, BooleanVal, boolean_val)
|
|
CAST_FUNCTION(FloatVal, BooleanVal, boolean_val)
|
|
CAST_FUNCTION(DoubleVal, BooleanVal, boolean_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, TinyIntVal, tiny_int_val)
|
|
CAST_FUNCTION(SmallIntVal, TinyIntVal, tiny_int_val)
|
|
CAST_FUNCTION(IntVal, TinyIntVal, tiny_int_val)
|
|
CAST_FUNCTION(BigIntVal, TinyIntVal, tiny_int_val)
|
|
CAST_FUNCTION(LargeIntVal, TinyIntVal, tiny_int_val)
|
|
CAST_FUNCTION(FloatVal, TinyIntVal, tiny_int_val)
|
|
CAST_FUNCTION(DoubleVal, TinyIntVal, tiny_int_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, SmallIntVal, small_int_val)
|
|
CAST_FUNCTION(TinyIntVal, SmallIntVal, small_int_val)
|
|
CAST_FUNCTION(IntVal, SmallIntVal, small_int_val)
|
|
CAST_FUNCTION(BigIntVal, SmallIntVal, small_int_val)
|
|
CAST_FUNCTION(LargeIntVal, SmallIntVal, small_int_val)
|
|
CAST_FUNCTION(FloatVal, SmallIntVal, small_int_val)
|
|
CAST_FUNCTION(DoubleVal, SmallIntVal, small_int_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, IntVal, int_val)
|
|
CAST_FUNCTION(TinyIntVal, IntVal, int_val)
|
|
CAST_FUNCTION(SmallIntVal, IntVal, int_val)
|
|
CAST_FUNCTION(BigIntVal, IntVal, int_val)
|
|
CAST_FUNCTION(LargeIntVal, IntVal, int_val)
|
|
CAST_FUNCTION(FloatVal, IntVal, int_val)
|
|
CAST_FUNCTION(DoubleVal, IntVal, int_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, BigIntVal, big_int_val)
|
|
CAST_FUNCTION(TinyIntVal, BigIntVal, big_int_val)
|
|
CAST_FUNCTION(SmallIntVal, BigIntVal, big_int_val)
|
|
CAST_FUNCTION(IntVal, BigIntVal, big_int_val)
|
|
CAST_FUNCTION(LargeIntVal, BigIntVal, big_int_val)
|
|
CAST_FUNCTION(FloatVal, BigIntVal, big_int_val)
|
|
CAST_FUNCTION(DoubleVal, BigIntVal, big_int_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, LargeIntVal, large_int_val)
|
|
CAST_FUNCTION(TinyIntVal, LargeIntVal, large_int_val)
|
|
CAST_FUNCTION(SmallIntVal, LargeIntVal, large_int_val)
|
|
CAST_FUNCTION(IntVal, LargeIntVal, large_int_val)
|
|
CAST_FUNCTION(BigIntVal, LargeIntVal, large_int_val)
|
|
CAST_FUNCTION(FloatVal, LargeIntVal, large_int_val)
|
|
CAST_FUNCTION(DoubleVal, LargeIntVal, large_int_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, FloatVal, float_val)
|
|
CAST_FUNCTION(TinyIntVal, FloatVal, float_val)
|
|
CAST_FUNCTION(SmallIntVal, FloatVal, float_val)
|
|
CAST_FUNCTION(IntVal, FloatVal, float_val)
|
|
CAST_FUNCTION(BigIntVal, FloatVal, float_val)
|
|
CAST_FUNCTION(LargeIntVal, FloatVal, float_val)
|
|
CAST_FUNCTION(DoubleVal, FloatVal, float_val)
|
|
|
|
CAST_FUNCTION(BooleanVal, DoubleVal, double_val)
|
|
CAST_FUNCTION(TinyIntVal, DoubleVal, double_val)
|
|
CAST_FUNCTION(SmallIntVal, DoubleVal, double_val)
|
|
CAST_FUNCTION(IntVal, DoubleVal, double_val)
|
|
CAST_FUNCTION(BigIntVal, DoubleVal, double_val)
|
|
CAST_FUNCTION(LargeIntVal, DoubleVal, double_val)
|
|
CAST_FUNCTION(FloatVal, DoubleVal, double_val)
|
|
|
|
#define CAST_FROM_STRING(num_type, type_name, native_type, string_parser_fn) \
|
|
num_type CastFunctions::cast_to_##type_name(FunctionContext* ctx, const StringVal& val) { \
|
|
if (val.is_null) return num_type::null(); \
|
|
StringParser::ParseResult result; \
|
|
num_type ret; \
|
|
ret.val = StringParser::string_parser_fn<native_type>(reinterpret_cast<char*>(val.ptr), \
|
|
val.len, &result); \
|
|
if (UNLIKELY(result != StringParser::PARSE_SUCCESS || std::isnan(ret.val) || \
|
|
std::isinf(ret.val))) { \
|
|
return num_type::null(); \
|
|
} \
|
|
return ret; \
|
|
}
|
|
|
|
#define CAST_FROM_STRINGS() \
|
|
CAST_FROM_STRING(TinyIntVal, tiny_int_val, int8_t, string_to_int); \
|
|
CAST_FROM_STRING(SmallIntVal, small_int_val, int16_t, string_to_int); \
|
|
CAST_FROM_STRING(IntVal, int_val, int32_t, string_to_int); \
|
|
CAST_FROM_STRING(BigIntVal, big_int_val, int64_t, string_to_int); \
|
|
CAST_FROM_STRING(LargeIntVal, large_int_val, __int128, string_to_int); \
|
|
CAST_FROM_STRING(FloatVal, float_val, float, string_to_float); \
|
|
CAST_FROM_STRING(DoubleVal, double_val, double, string_to_float);
|
|
|
|
CAST_FROM_STRINGS();
|
|
|
|
#define CAST_TO_STRING(num_type) \
|
|
StringVal CastFunctions::cast_to_string_val(FunctionContext* ctx, const num_type& val) { \
|
|
if (val.is_null) return StringVal::null(); \
|
|
auto f = fmt::format_int(val.val); \
|
|
return AnyValUtil::from_buffer_temp(ctx, f.data(), f.size()); \
|
|
}
|
|
|
|
CAST_TO_STRING(BooleanVal);
|
|
CAST_TO_STRING(TinyIntVal);
|
|
CAST_TO_STRING(SmallIntVal);
|
|
CAST_TO_STRING(IntVal);
|
|
CAST_TO_STRING(BigIntVal);
|
|
|
|
StringVal CastFunctions::cast_to_string_val(FunctionContext* ctx, const LargeIntVal& val) {
|
|
if (val.is_null) {
|
|
return StringVal::null();
|
|
}
|
|
|
|
auto string_value = LargeIntValue::to_string(val.val);
|
|
return AnyValUtil::from_buffer_temp(ctx, string_value.data(), string_value.size());
|
|
}
|
|
|
|
template <typename T>
|
|
int float_to_string(T value, char* buf);
|
|
|
|
template <>
|
|
int float_to_string<float>(float value, char* buf) {
|
|
return FloatToBuffer(value, MAX_FLOAT_STR_LENGTH + 2, buf);
|
|
}
|
|
|
|
template <>
|
|
int float_to_string<double>(double value, char* buf) {
|
|
return DoubleToBuffer(value, MAX_DOUBLE_STR_LENGTH + 2, buf);
|
|
}
|
|
|
|
#define CAST_FLOAT_TO_STRING(float_type, format) \
|
|
StringVal CastFunctions::cast_to_string_val(FunctionContext* ctx, const float_type& val) { \
|
|
if (val.is_null) return StringVal::null(); \
|
|
/* val.val could be -nan, return "nan" instead */ \
|
|
if (std::isnan(val.val)) return StringVal("nan"); \
|
|
/* Add 1 to MAX_FLOAT_CHARS since snprintf adds a trailing '\0' */ \
|
|
StringVal sv(ctx, MAX_DOUBLE_STR_LENGTH + 2); \
|
|
if (UNLIKELY(sv.is_null)) { \
|
|
return sv; \
|
|
} \
|
|
const FunctionContext::TypeDesc& returnType = ctx->get_return_type(); \
|
|
if (returnType.len > 0) { \
|
|
sv.len = snprintf(reinterpret_cast<char*>(sv.ptr), sv.len, format, val.val); \
|
|
DCHECK_GT(sv.len, 0); \
|
|
DCHECK_LE(sv.len, MAX_FLOAT_CHARS); \
|
|
AnyValUtil::TruncateIfNecessary(returnType, &sv); \
|
|
} else if (returnType.len == -1) { \
|
|
char buf[MAX_DOUBLE_STR_LENGTH + 2]; \
|
|
sv.len = float_to_string(val.val, buf); \
|
|
memcpy(sv.ptr, buf, sv.len); \
|
|
} else { \
|
|
DCHECK(false); \
|
|
} \
|
|
return sv; \
|
|
}
|
|
|
|
// Floats have up to 9 significant digits, doubles up to 17
|
|
// (see http://en.wikipedia.org/wiki/Single-precision_floating-point_format
|
|
// and http://en.wikipedia.org/wiki/Double-precision_floating-point_format)
|
|
CAST_FLOAT_TO_STRING(FloatVal, "%.9g");
|
|
CAST_FLOAT_TO_STRING(DoubleVal, "%.17g");
|
|
|
|
StringVal CastFunctions::cast_to_string_val(FunctionContext* ctx, const DateTimeVal& val) {
|
|
if (val.is_null) {
|
|
return StringVal::null();
|
|
}
|
|
DateTimeValue tv = DateTimeValue::from_datetime_val(val);
|
|
StringVal sv = StringVal::create_temp_string_val(ctx, 64);
|
|
sv.len = tv.to_string((char*)sv.ptr) - (char*)sv.ptr - 1;
|
|
return sv;
|
|
}
|
|
|
|
StringVal CastFunctions::cast_to_string_val(FunctionContext* ctx, const StringVal& val) {
|
|
if (val.is_null) return StringVal::null();
|
|
StringVal sv;
|
|
sv.ptr = val.ptr;
|
|
sv.len = val.len;
|
|
|
|
const FunctionContext::TypeDesc& result_type = ctx->get_return_type();
|
|
if (result_type.len > 0) {
|
|
AnyValUtil::TruncateIfNecessary(result_type, &sv);
|
|
}
|
|
return sv;
|
|
}
|
|
|
|
BooleanVal CastFunctions::cast_to_boolean_val(FunctionContext* ctx, const StringVal& val) {
|
|
if (val.is_null) {
|
|
return BooleanVal::null();
|
|
}
|
|
StringParser::ParseResult result;
|
|
BooleanVal ret;
|
|
IntVal int_val = cast_to_int_val(ctx, val);
|
|
if (!int_val.is_null && int_val.val == 0) {
|
|
ret.val = false;
|
|
} else if (!int_val.is_null && int_val.val == 1) {
|
|
ret.val = true;
|
|
} else {
|
|
ret.val = StringParser::string_to_bool(reinterpret_cast<char*>(val.ptr), val.len, &result);
|
|
if (UNLIKELY(result != StringParser::PARSE_SUCCESS)) {
|
|
return BooleanVal::null();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#define CAST_FROM_DATETIME(to_type, type_name) \
|
|
to_type CastFunctions::cast_to_##type_name(FunctionContext* ctx, const DateTimeVal& val) { \
|
|
if (val.is_null) return to_type::null(); \
|
|
DateTimeValue tv = DateTimeValue::from_datetime_val(val); \
|
|
return to_type(tv.to_int64()); \
|
|
}
|
|
|
|
CAST_FROM_DATETIME(BooleanVal, boolean_val);
|
|
CAST_FROM_DATETIME(TinyIntVal, tiny_int_val);
|
|
CAST_FROM_DATETIME(SmallIntVal, small_int_val);
|
|
CAST_FROM_DATETIME(IntVal, int_val);
|
|
CAST_FROM_DATETIME(BigIntVal, big_int_val);
|
|
CAST_FROM_DATETIME(LargeIntVal, large_int_val);
|
|
CAST_FROM_DATETIME(FloatVal, float_val);
|
|
CAST_FROM_DATETIME(DoubleVal, double_val);
|
|
|
|
#define CAST_TO_DATETIME(from_type) \
|
|
DateTimeVal CastFunctions::cast_to_datetime_val(FunctionContext* ctx, const from_type& val) { \
|
|
if (val.is_null) return DateTimeVal::null(); \
|
|
DateTimeValue date_value; \
|
|
if (!date_value.from_date_int64(val.val)) return DateTimeVal::null(); \
|
|
date_value.to_datetime(); \
|
|
DateTimeVal result; \
|
|
date_value.to_datetime_val(&result); \
|
|
return result; \
|
|
}
|
|
|
|
#define CAST_TO_DATETIMES() \
|
|
CAST_TO_DATETIME(TinyIntVal); \
|
|
CAST_TO_DATETIME(SmallIntVal); \
|
|
CAST_TO_DATETIME(IntVal); \
|
|
CAST_TO_DATETIME(BigIntVal); \
|
|
CAST_TO_DATETIME(LargeIntVal); \
|
|
CAST_TO_DATETIME(FloatVal); \
|
|
CAST_TO_DATETIME(DoubleVal);
|
|
|
|
CAST_TO_DATETIMES();
|
|
|
|
#define CAST_TO_DATE(from_type) \
|
|
DateTimeVal CastFunctions::cast_to_date_val(FunctionContext* ctx, const from_type& val) { \
|
|
if (val.is_null) return DateTimeVal::null(); \
|
|
DateTimeValue date_value; \
|
|
if (!date_value.from_date_int64(val.val)) return DateTimeVal::null(); \
|
|
date_value.cast_to_date(); \
|
|
DateTimeVal result; \
|
|
date_value.to_datetime_val(&result); \
|
|
return result; \
|
|
}
|
|
|
|
#define CAST_TO_DATES() \
|
|
CAST_TO_DATE(TinyIntVal); \
|
|
CAST_TO_DATE(SmallIntVal); \
|
|
CAST_TO_DATE(IntVal); \
|
|
CAST_TO_DATE(BigIntVal); \
|
|
CAST_TO_DATE(LargeIntVal); \
|
|
CAST_TO_DATE(FloatVal); \
|
|
CAST_TO_DATE(DoubleVal);
|
|
|
|
CAST_TO_DATES();
|
|
|
|
DateTimeVal CastFunctions::cast_to_datetime_val(FunctionContext* ctx, const DateTimeVal& val) {
|
|
if (val.is_null) {
|
|
return DateTimeVal::null();
|
|
}
|
|
DateTimeValue date_value = DateTimeValue::from_datetime_val(val);
|
|
date_value.to_datetime();
|
|
// Return null if 'val' did not parse
|
|
DateTimeVal result;
|
|
date_value.to_datetime_val(&result);
|
|
return result;
|
|
}
|
|
|
|
DateTimeVal CastFunctions::cast_to_datetime_val(FunctionContext* ctx, const StringVal& val) {
|
|
if (val.is_null) {
|
|
return DateTimeVal::null();
|
|
}
|
|
DateTimeValue date_value;
|
|
if (!date_value.from_date_str((char*)val.ptr, val.len)) {
|
|
return DateTimeVal::null();
|
|
}
|
|
date_value.to_datetime();
|
|
// Return null if 'val' did not parse
|
|
DateTimeVal result;
|
|
date_value.to_datetime_val(&result);
|
|
return result;
|
|
}
|
|
|
|
DateTimeVal CastFunctions::cast_to_date_val(FunctionContext* ctx, const DateTimeVal& val) {
|
|
if (val.is_null) {
|
|
return DateTimeVal::null();
|
|
}
|
|
DateTimeValue date_value = DateTimeValue::from_datetime_val(val);
|
|
date_value.cast_to_date();
|
|
// Return null if 'val' did not parse
|
|
DateTimeVal result;
|
|
date_value.to_datetime_val(&result);
|
|
return result;
|
|
}
|
|
|
|
DateTimeVal CastFunctions::cast_to_date_val(FunctionContext* ctx, const StringVal& val) {
|
|
if (val.is_null) {
|
|
return DateTimeVal::null();
|
|
}
|
|
DateTimeValue date_value;
|
|
if (!date_value.from_date_str((char*)val.ptr, val.len)) {
|
|
return DateTimeVal::null();
|
|
}
|
|
date_value.cast_to_date();
|
|
// Return null if 'val' did not parse
|
|
DateTimeVal result;
|
|
date_value.to_datetime_val(&result);
|
|
return result;
|
|
}
|
|
|
|
CollectionVal CastFunctions::cast_to_array_val(FunctionContext* context, const StringVal& val) {
|
|
CollectionVal array_val;
|
|
Status status = ArrayParser::parse(array_val, context, val);
|
|
return status.ok() ? array_val : CollectionVal::null();
|
|
}
|
|
|
|
} // namespace doris
|