Repository: impala Updated Branches: refs/drafts/IMPALA-6169_date_type [created] cfc448db0
IMPALA-7875: Make Date a supported type Project: http://git-wip-us.apache.org/repos/asf/impala/repo Commit: http://git-wip-us.apache.org/repos/asf/impala/commit/cfc448db Tree: http://git-wip-us.apache.org/repos/asf/impala/tree/cfc448db Diff: http://git-wip-us.apache.org/repos/asf/impala/diff/cfc448db Branch: refs/drafts/IMPALA-6169_date_type Commit: cfc448db0de4ce5d15c3068b6d4b36aa43635562 Parents: cd26e80 Author: Gabor Kaszab <[email protected]> Authored: Tue Nov 20 10:48:50 2018 +0100 Committer: Gabor Kaszab <[email protected]> Committed: Wed Nov 21 10:27:07 2018 +0100 ---------------------------------------------------------------------- be/src/exprs/cast-functions-ir.cc | 59 ++++++++++++++++++++ be/src/exprs/cast-functions.h | 20 +++++++ be/src/exprs/decimal-operators-ir.cc | 2 + be/src/exprs/decimal-operators.h | 3 + be/src/exprs/in-predicate-ir.cc | 1 + be/src/exprs/in-predicate.h | 22 ++++++++ be/src/exprs/is-null-predicate-ir.cc | 2 + be/src/exprs/operators-ir.cc | 2 + be/src/exprs/operators.h | 11 ++++ be/src/runtime/date-value.cc | 10 ++++ be/src/runtime/date-value.h | 9 +++ be/src/udf/udf.h | 26 ++++++++- be/src/util/symbols-util.cc | 3 + .../org/apache/impala/catalog/Function.java | 2 + .../apache/impala/catalog/ScalarFunction.java | 3 + .../java/org/apache/impala/catalog/Type.java | 2 +- 16 files changed, 175 insertions(+), 2 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/cast-functions-ir.cc ---------------------------------------------------------------------- diff --git a/be/src/exprs/cast-functions-ir.cc b/be/src/exprs/cast-functions-ir.cc index 45f79e0..78708bf 100644 --- a/be/src/exprs/cast-functions-ir.cc +++ b/be/src/exprs/cast-functions-ir.cc @@ -19,10 +19,12 @@ #include <cmath> +#include <boost/date_time/gregorian/gregorian.hpp> #include <boost/lexical_cast.hpp> #include "exprs/anyval-util.h" #include "exprs/decimal-functions.h" +#include "runtime/date-value.h" #include "runtime/runtime-state.h" #include "runtime/string-value.inline.h" #include "runtime/timestamp-value.h" @@ -52,6 +54,7 @@ CAST_FUNCTION(IntVal, BooleanVal) CAST_FUNCTION(BigIntVal, BooleanVal) CAST_FUNCTION(FloatVal, BooleanVal) CAST_FUNCTION(DoubleVal, BooleanVal) +CAST_FUNCTION(DateVal, BooleanVal) CAST_FUNCTION(BooleanVal, TinyIntVal) CAST_FUNCTION(SmallIntVal, TinyIntVal) @@ -59,6 +62,7 @@ CAST_FUNCTION(IntVal, TinyIntVal) CAST_FUNCTION(BigIntVal, TinyIntVal) CAST_FUNCTION(FloatVal, TinyIntVal) CAST_FUNCTION(DoubleVal, TinyIntVal) +CAST_FUNCTION(DateVal, TinyIntVal) CAST_FUNCTION(BooleanVal, SmallIntVal) CAST_FUNCTION(TinyIntVal, SmallIntVal) @@ -66,6 +70,7 @@ CAST_FUNCTION(IntVal, SmallIntVal) CAST_FUNCTION(BigIntVal, SmallIntVal) CAST_FUNCTION(FloatVal, SmallIntVal) CAST_FUNCTION(DoubleVal, SmallIntVal) +CAST_FUNCTION(DateVal, SmallIntVal) CAST_FUNCTION(BooleanVal, IntVal) CAST_FUNCTION(TinyIntVal, IntVal) @@ -73,6 +78,7 @@ CAST_FUNCTION(SmallIntVal, IntVal) CAST_FUNCTION(BigIntVal, IntVal) CAST_FUNCTION(FloatVal, IntVal) CAST_FUNCTION(DoubleVal, IntVal) +CAST_FUNCTION(DateVal, IntVal) CAST_FUNCTION(BooleanVal, BigIntVal) CAST_FUNCTION(TinyIntVal, BigIntVal) @@ -80,6 +86,7 @@ CAST_FUNCTION(SmallIntVal, BigIntVal) CAST_FUNCTION(IntVal, BigIntVal) CAST_FUNCTION(FloatVal, BigIntVal) CAST_FUNCTION(DoubleVal, BigIntVal) +CAST_FUNCTION(DateVal, BigIntVal) CAST_FUNCTION(BooleanVal, FloatVal) CAST_FUNCTION(TinyIntVal, FloatVal) @@ -87,6 +94,7 @@ CAST_FUNCTION(SmallIntVal, FloatVal) CAST_FUNCTION(IntVal, FloatVal) CAST_FUNCTION(BigIntVal, FloatVal) CAST_FUNCTION(DoubleVal, FloatVal) +CAST_FUNCTION(DateVal, FloatVal) CAST_FUNCTION(BooleanVal, DoubleVal) CAST_FUNCTION(TinyIntVal, DoubleVal) @@ -94,6 +102,15 @@ CAST_FUNCTION(SmallIntVal, DoubleVal) CAST_FUNCTION(IntVal, DoubleVal) CAST_FUNCTION(BigIntVal, DoubleVal) CAST_FUNCTION(FloatVal, DoubleVal) +CAST_FUNCTION(DateVal, DoubleVal) + +CAST_FUNCTION(BooleanVal, DateVal) +CAST_FUNCTION(TinyIntVal, DateVal) +CAST_FUNCTION(SmallIntVal, DateVal) +CAST_FUNCTION(IntVal, DateVal) +CAST_FUNCTION(BigIntVal, DateVal) +CAST_FUNCTION(FloatVal, DateVal) +CAST_FUNCTION(DoubleVal, DateVal) #define CAST_FROM_STRING(num_type, native_type, string_parser_fn) \ num_type CastFunctions::CastTo##num_type(FunctionContext* ctx, const StringVal& val) { \ @@ -177,6 +194,15 @@ StringVal CastFunctions::CastToStringVal(FunctionContext* ctx, const StringVal& return sv; } +StringVal CastFunctions::CastToStringVal(FunctionContext* ctx, const DateVal& val) { + if (val.is_null) return StringVal::null(); + DateValue dv = DateValue::FromDateVal(val); + if (UNLIKELY(!dv.IsValid())) return StringVal::null(); + StringVal sv = AnyValUtil::FromString(ctx, lexical_cast<string>(dv)); + AnyValUtil::TruncateIfNecessary(ctx->GetReturnType(), &sv); + return sv; +} + StringVal CastFunctions::CastToChar(FunctionContext* ctx, const StringVal& val) { if (val.is_null) return StringVal::null(); @@ -265,6 +291,23 @@ CAST_TO_TIMESTAMP(SmallIntVal); CAST_TO_TIMESTAMP(IntVal); CAST_TO_TIMESTAMP(BigIntVal); +TimestampVal CastFunctions::CastToTimestampVal(FunctionContext* ctx, const DateVal& val) { + if (val.is_null) return TimestampVal::null(); + const DateValue dv = DateValue::FromDateVal(val); + + int year, month, day; + if (UNLIKELY(!dv.ToYearMonthDay(&year, &month, &day))) return TimestampVal::null(); + if (year < 1400 || year > 9999) return TimestampVal::null(); + + const boost::gregorian::date d(year, month, day); + const boost::posix_time::time_duration t(0, 0, 0, 0); + TimestampValue tv(d, t); + + TimestampVal result; + tv.ToTimestampVal(&result); + return result; +} + TimestampVal CastFunctions::CastToTimestampVal(FunctionContext* ctx, const StringVal& val) { if (val.is_null) return TimestampVal::null(); @@ -274,3 +317,19 @@ TimestampVal CastFunctions::CastToTimestampVal(FunctionContext* ctx, tv.ToTimestampVal(&result); return result; } + +DateVal CastFunctions::CastToDateVal(FunctionContext* ctx, const StringVal& val) { + if (val.is_null) return DateVal::null(); + DateValue dv = DateValue::Parse(reinterpret_cast<char*>(val.ptr), val.len); + return dv.ToDateVal(); +} + +DateVal CastFunctions::CastToDateVal(FunctionContext* ctx, const TimestampVal& val) { + if (val.is_null) return DateVal::null(); + TimestampValue tv = TimestampValue::FromTimestampVal(val); + if (UNLIKELY(!tv.HasDate())) return DateVal::null(); + + const boost::gregorian::date d = tv.date(); + const DateValue dv(d.year(), d.month(), d.day()); + return dv.ToDateVal(); +} http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/cast-functions.h ---------------------------------------------------------------------- diff --git a/be/src/exprs/cast-functions.h b/be/src/exprs/cast-functions.h index f5389ce..1458dd7 100644 --- a/be/src/exprs/cast-functions.h +++ b/be/src/exprs/cast-functions.h @@ -32,6 +32,7 @@ using impala_udf::IntVal; using impala_udf::BigIntVal; using impala_udf::FloatVal; using impala_udf::DoubleVal; +using impala_udf::DateVal; using impala_udf::TimestampVal; using impala_udf::StringVal; using impala_udf::DecimalVal; @@ -45,6 +46,7 @@ class CastFunctions { static BooleanVal CastToBooleanVal(FunctionContext* context, const FloatVal& val); static BooleanVal CastToBooleanVal(FunctionContext* context, const DoubleVal& val); static BooleanVal CastToBooleanVal(FunctionContext* context, const TimestampVal& val); + static BooleanVal CastToBooleanVal(FunctionContext* context, const DateVal& val); static TinyIntVal CastToTinyIntVal(FunctionContext* context, const BooleanVal& val); static TinyIntVal CastToTinyIntVal(FunctionContext* context, const SmallIntVal& val); @@ -54,6 +56,7 @@ class CastFunctions { static TinyIntVal CastToTinyIntVal(FunctionContext* context, const DoubleVal& val); static TinyIntVal CastToTinyIntVal(FunctionContext* context, const StringVal& val); static TinyIntVal CastToTinyIntVal(FunctionContext* context, const TimestampVal& val); + static TinyIntVal CastToTinyIntVal(FunctionContext* context, const DateVal& val); static SmallIntVal CastToSmallIntVal(FunctionContext* context, const BooleanVal& val); static SmallIntVal CastToSmallIntVal(FunctionContext* context, const TinyIntVal& val); @@ -63,6 +66,7 @@ class CastFunctions { static SmallIntVal CastToSmallIntVal(FunctionContext* context, const DoubleVal& val); static SmallIntVal CastToSmallIntVal(FunctionContext* context, const StringVal& val); static SmallIntVal CastToSmallIntVal(FunctionContext* context, const TimestampVal& val); + static SmallIntVal CastToSmallIntVal(FunctionContext* context, const DateVal& val); static IntVal CastToIntVal(FunctionContext* context, const BooleanVal& val); static IntVal CastToIntVal(FunctionContext* context, const TinyIntVal& val); @@ -72,6 +76,7 @@ class CastFunctions { static IntVal CastToIntVal(FunctionContext* context, const DoubleVal& val); static IntVal CastToIntVal(FunctionContext* context, const StringVal& val); static IntVal CastToIntVal(FunctionContext* context, const TimestampVal& val); + static IntVal CastToIntVal(FunctionContext* context, const DateVal& val); static BigIntVal CastToBigIntVal(FunctionContext* context, const BooleanVal& val); static BigIntVal CastToBigIntVal(FunctionContext* context, const TinyIntVal& val); @@ -81,6 +86,7 @@ class CastFunctions { static BigIntVal CastToBigIntVal(FunctionContext* context, const DoubleVal& val); static BigIntVal CastToBigIntVal(FunctionContext* context, const StringVal& val); static BigIntVal CastToBigIntVal(FunctionContext* context, const TimestampVal& val); + static BigIntVal CastToBigIntVal(FunctionContext* context, const DateVal& val); static FloatVal CastToFloatVal(FunctionContext* context, const BooleanVal& val); static FloatVal CastToFloatVal(FunctionContext* context, const TinyIntVal& val); @@ -90,6 +96,7 @@ class CastFunctions { static FloatVal CastToFloatVal(FunctionContext* context, const DoubleVal& val); static FloatVal CastToFloatVal(FunctionContext* context, const StringVal& val); static FloatVal CastToFloatVal(FunctionContext* context, const TimestampVal& val); + static FloatVal CastToFloatVal(FunctionContext* context, const DateVal& val); static DoubleVal CastToDoubleVal(FunctionContext* context, const BooleanVal& val); static DoubleVal CastToDoubleVal(FunctionContext* context, const TinyIntVal& val); @@ -99,6 +106,7 @@ class CastFunctions { static DoubleVal CastToDoubleVal(FunctionContext* context, const FloatVal& val); static DoubleVal CastToDoubleVal(FunctionContext* context, const StringVal& val); static DoubleVal CastToDoubleVal(FunctionContext* context, const TimestampVal& val); + static DoubleVal CastToDoubleVal(FunctionContext* context, const DateVal& val); static StringVal CastToStringVal(FunctionContext* context, const BooleanVal& val); static StringVal CastToStringVal(FunctionContext* context, const TinyIntVal& val); @@ -109,6 +117,7 @@ class CastFunctions { static StringVal CastToStringVal(FunctionContext* context, const DoubleVal& val); static StringVal CastToStringVal(FunctionContext* context, const TimestampVal& val); static StringVal CastToStringVal(FunctionContext* context, const StringVal& val); + static StringVal CastToStringVal(FunctionContext* context, const DateVal& val); static StringVal CastToChar(FunctionContext* context, const StringVal& val); @@ -120,6 +129,17 @@ class CastFunctions { static TimestampVal CastToTimestampVal(FunctionContext* context, const FloatVal& val); static TimestampVal CastToTimestampVal(FunctionContext* context, const DoubleVal& val); static TimestampVal CastToTimestampVal(FunctionContext* context, const StringVal& val); + static TimestampVal CastToTimestampVal(FunctionContext* context, const DateVal& val); + + static DateVal CastToDateVal(FunctionContext* context, const BooleanVal& val); + static DateVal CastToDateVal(FunctionContext* context, const TinyIntVal& val); + static DateVal CastToDateVal(FunctionContext* context, const SmallIntVal& val); + static DateVal CastToDateVal(FunctionContext* context, const IntVal& val); + static DateVal CastToDateVal(FunctionContext* context, const BigIntVal& val); + static DateVal CastToDateVal(FunctionContext* context, const FloatVal& val); + static DateVal CastToDateVal(FunctionContext* context, const DoubleVal& val); + static DateVal CastToDateVal(FunctionContext* context, const StringVal& val); + static DateVal CastToDateVal(FunctionContext* context, const TimestampVal& val); }; } http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/decimal-operators-ir.cc ---------------------------------------------------------------------- diff --git a/be/src/exprs/decimal-operators-ir.cc b/be/src/exprs/decimal-operators-ir.cc index c987b9d..917f33b 100644 --- a/be/src/exprs/decimal-operators-ir.cc +++ b/be/src/exprs/decimal-operators-ir.cc @@ -367,6 +367,7 @@ CAST_INT_TO_DECIMAL(IntVal) CAST_INT_TO_DECIMAL(BigIntVal) CAST_FLOAT_TO_DECIMAL(FloatVal) CAST_FLOAT_TO_DECIMAL(DoubleVal) +CAST_FLOAT_TO_DECIMAL(DateVal) CAST_DECIMAL_TO_INT(TinyIntVal) CAST_DECIMAL_TO_INT(SmallIntVal) @@ -374,6 +375,7 @@ CAST_DECIMAL_TO_INT(IntVal) CAST_DECIMAL_TO_INT(BigIntVal) CAST_DECIMAL_TO_FLOAT(FloatVal) CAST_DECIMAL_TO_FLOAT(DoubleVal) +CAST_DECIMAL_TO_FLOAT(DateVal) // Inline in IR module so branches can be optimised out. IR_ALWAYS_INLINE DecimalVal DecimalOperators::RoundDecimalNegativeScale( http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/decimal-operators.h ---------------------------------------------------------------------- diff --git a/be/src/exprs/decimal-operators.h b/be/src/exprs/decimal-operators.h index 235c1d2..b035e61 100644 --- a/be/src/exprs/decimal-operators.h +++ b/be/src/exprs/decimal-operators.h @@ -36,6 +36,7 @@ using impala_udf::IntVal; using impala_udf::BigIntVal; using impala_udf::FloatVal; using impala_udf::DoubleVal; +using impala_udf::DateVal; using impala_udf::TimestampVal; using impala_udf::StringVal; using impala_udf::DecimalVal; @@ -57,6 +58,7 @@ class DecimalOperators { static DecimalVal CastToDecimalVal(FunctionContext*, const FloatVal&); static DecimalVal CastToDecimalVal(FunctionContext*, const DoubleVal&); static DecimalVal CastToDecimalVal(FunctionContext*, const StringVal&); + static DecimalVal CastToDecimalVal(FunctionContext*, const DateVal&); static BooleanVal CastToBooleanVal(FunctionContext*, const DecimalVal&); static TinyIntVal CastToTinyIntVal(FunctionContext*, const DecimalVal&); @@ -67,6 +69,7 @@ class DecimalOperators { static DoubleVal CastToDoubleVal(FunctionContext*, const DecimalVal&); static StringVal CastToStringVal(FunctionContext*, const DecimalVal&); static TimestampVal CastToTimestampVal(FunctionContext*, const DecimalVal&); + static DateVal CastToDateVal(FunctionContext*, const DecimalVal&); static DecimalVal Add_DecimalVal_DecimalVal( FunctionContext*, const DecimalVal&, const DecimalVal&); http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/in-predicate-ir.cc ---------------------------------------------------------------------- diff --git a/be/src/exprs/in-predicate-ir.cc b/be/src/exprs/in-predicate-ir.cc index 998fae0..9c1210d 100644 --- a/be/src/exprs/in-predicate-ir.cc +++ b/be/src/exprs/in-predicate-ir.cc @@ -74,5 +74,6 @@ IN_FUNCTIONS(DoubleVal, double, double) IN_FUNCTIONS(StringVal, StringValue, string) IN_FUNCTIONS(TimestampVal, TimestampValue, timestamp) IN_FUNCTIONS(DecimalVal, Decimal16Value, decimal) +IN_FUNCTIONS(DateVal, int32_t, date) } http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/in-predicate.h ---------------------------------------------------------------------- diff --git a/be/src/exprs/in-predicate.h b/be/src/exprs/in-predicate.h index 87ae8b8..c99acae 100644 --- a/be/src/exprs/in-predicate.h +++ b/be/src/exprs/in-predicate.h @@ -138,6 +138,28 @@ class InPredicate { int num_args, const impala_udf::IntVal* args); static impala_udf::BooleanVal InIterate( + impala_udf::FunctionContext* context, const impala_udf::DateVal& val, + int num_args, const impala_udf::DateVal* args); + + static impala_udf::BooleanVal NotInIterate( + impala_udf::FunctionContext* context, const impala_udf::DateVal& val, + int num_args, const impala_udf::DateVal* args); + + static void SetLookupPrepare_date(impala_udf::FunctionContext* ctx, + impala_udf::FunctionContext::FunctionStateScope scope); + + static void SetLookupClose_date(impala_udf::FunctionContext* ctx, + impala_udf::FunctionContext::FunctionStateScope scope); + + static impala_udf::BooleanVal InSetLookup( + impala_udf::FunctionContext* context, const impala_udf::DateVal& val, + int num_args, const impala_udf::DateVal* args); + + static impala_udf::BooleanVal NotInSetLookup( + impala_udf::FunctionContext* context, const impala_udf::DateVal& val, + int num_args, const impala_udf::DateVal* args); + + static impala_udf::BooleanVal InIterate( impala_udf::FunctionContext* context, const impala_udf::BigIntVal& val, int num_args, const impala_udf::BigIntVal* args); http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/is-null-predicate-ir.cc ---------------------------------------------------------------------- diff --git a/be/src/exprs/is-null-predicate-ir.cc b/be/src/exprs/is-null-predicate-ir.cc index b21f61c..e2308f5 100644 --- a/be/src/exprs/is-null-predicate-ir.cc +++ b/be/src/exprs/is-null-predicate-ir.cc @@ -42,6 +42,7 @@ template BooleanVal IsNullPredicate::IsNull(FunctionContext*, const DoubleVal&); template BooleanVal IsNullPredicate::IsNull(FunctionContext*, const StringVal&); template BooleanVal IsNullPredicate::IsNull(FunctionContext*, const TimestampVal&); template BooleanVal IsNullPredicate::IsNull(FunctionContext*, const DecimalVal&); +template BooleanVal IsNullPredicate::IsNull(FunctionContext*, const DateVal&); template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const BooleanVal&); template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const TinyIntVal&); @@ -53,5 +54,6 @@ template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const DoubleVal template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const StringVal&); template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const TimestampVal&); template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const DecimalVal&); +template BooleanVal IsNullPredicate::IsNotNull(FunctionContext*, const DateVal&); } http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/operators-ir.cc ---------------------------------------------------------------------- diff --git a/be/src/exprs/operators-ir.cc b/be/src/exprs/operators-ir.cc index 6ef8d50..6bd2942 100644 --- a/be/src/exprs/operators-ir.cc +++ b/be/src/exprs/operators-ir.cc @@ -172,6 +172,7 @@ BINARY_PREDICATE_NUMERIC_FN(NAME, BigIntVal, OP);\ BINARY_PREDICATE_NUMERIC_FN(NAME, FloatVal, OP);\ BINARY_PREDICATE_NUMERIC_FN(NAME, DoubleVal, OP);\ + BINARY_PREDICATE_NUMERIC_FN(NAME, DateVal, OP);\ BINARY_PREDICATE_NONNUMERIC_FN(NAME, StringVal, StringValue, OP);\ BINARY_PREDICATE_NONNUMERIC_FN(NAME, TimestampVal, TimestampValue, OP);\ BINARY_PREDICATE_CHAR(NAME, OP); @@ -184,6 +185,7 @@ NULLSAFE_NUMERIC_DISTINCTION(NAME, BigIntVal, OP, IS_EQUAL); \ NULLSAFE_NUMERIC_DISTINCTION(NAME, FloatVal, OP, IS_EQUAL); \ NULLSAFE_NUMERIC_DISTINCTION(NAME, DoubleVal, OP, IS_EQUAL); \ + NULLSAFE_NUMERIC_DISTINCTION(NAME, DateVal, OP, IS_EQUAL); \ NULLSAFE_NONNUMERIC_DISTINCTION(NAME, StringVal, StringValue, OP, IS_EQUAL);\ NULLSAFE_NONNUMERIC_DISTINCTION(NAME, TimestampVal, TimestampValue, OP, IS_EQUAL);\ NULLSAFE_CHAR_DISTINCTION(NAME, OP, IS_EQUAL); http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/exprs/operators.h ---------------------------------------------------------------------- diff --git a/be/src/exprs/operators.h b/be/src/exprs/operators.h index d3920e8..544d608 100644 --- a/be/src/exprs/operators.h +++ b/be/src/exprs/operators.h @@ -34,6 +34,7 @@ using impala_udf::DoubleVal; using impala_udf::TimestampVal; using impala_udf::StringVal; using impala_udf::DecimalVal; +using impala_udf::DateVal; /// Operators written against the UDF interface. class Operators { @@ -145,6 +146,7 @@ class Operators { static BooleanVal Eq_Char_Char(FunctionContext*, const StringVal&, const StringVal&); static BooleanVal Eq_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal Eq_DateVal_DateVal(FunctionContext*, const DateVal&, const DateVal&); static BooleanVal Ne_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -164,6 +166,7 @@ class Operators { static BooleanVal Ne_Char_Char(FunctionContext*, const StringVal&, const StringVal&); static BooleanVal Ne_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal Ne_DateVal_DateVal(FunctionContext*, const DateVal&, const DateVal&); static BooleanVal DistinctFrom_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -185,6 +188,8 @@ class Operators { FunctionContext*, const StringVal&, const StringVal&); static BooleanVal DistinctFrom_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal DistinctFrom_DateVal_DateVal( + FunctionContext*, const DateVal&, const DateVal&); static BooleanVal NotDistinct_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -206,6 +211,8 @@ class Operators { FunctionContext*, const StringVal&, const StringVal&); static BooleanVal NotDistinct_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal NotDistinct_DateVal_DateVal( + FunctionContext*, const DateVal&, const DateVal&); static BooleanVal Gt_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -225,6 +232,7 @@ class Operators { static BooleanVal Gt_Char_Char(FunctionContext*, const StringVal&, const StringVal&); static BooleanVal Gt_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal Gt_DateVal_DateVal(FunctionContext*, const DateVal&, const DateVal&); static BooleanVal Lt_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -244,6 +252,7 @@ class Operators { static BooleanVal Lt_Char_Char(FunctionContext*, const StringVal&, const StringVal&); static BooleanVal Lt_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal Lt_DateVal_DateVal(FunctionContext*, const DateVal&, const DateVal&); static BooleanVal Ge_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -263,6 +272,7 @@ class Operators { static BooleanVal Ge_Char_Char( FunctionContext*, const StringVal&, const StringVal&); static BooleanVal Ge_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal Ge_DateVal_DateVal(FunctionContext*, const DateVal&, const DateVal&); static BooleanVal Le_BooleanVal_BooleanVal( FunctionContext*, const BooleanVal&, const BooleanVal&); @@ -282,6 +292,7 @@ class Operators { static BooleanVal Le_Char_Char(FunctionContext*, const StringVal&, const StringVal&); static BooleanVal Le_TimestampVal_TimestampVal( FunctionContext*, const TimestampVal&, const TimestampVal&); + static BooleanVal Le_DateVal_DateVal(FunctionContext*, const DateVal&, const DateVal&); }; } // namespace impala http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/runtime/date-value.cc ---------------------------------------------------------------------- diff --git a/be/src/runtime/date-value.cc b/be/src/runtime/date-value.cc index 7223290..7829ed5 100644 --- a/be/src/runtime/date-value.cc +++ b/be/src/runtime/date-value.cc @@ -60,6 +60,16 @@ DateValue::DateValue(int year, int month, int day) } } +impala_udf::DateVal DateValue::ToDateVal() const { + if (!IsValid()) return impala_udf::DateVal::null(); + return impala_udf::DateVal(days_since_epoch_); +} + +DateValue DateValue::FromDateVal(const impala_udf::DateVal& udf_value) { + DCHECK(!udf_value.is_null); + return DateValue(udf_value.val); +} + DateValue DateValue::Parse(const char* str, int len) { DateValue dv; DateParser::Parse(str, len, &dv); http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/runtime/date-value.h ---------------------------------------------------------------------- diff --git a/be/src/runtime/date-value.h b/be/src/runtime/date-value.h index 17e5f01..2d4552b 100644 --- a/be/src/runtime/date-value.h +++ b/be/src/runtime/date-value.h @@ -23,6 +23,7 @@ #include "common/logging.h" #include "common/status.h" +#include "udf/udf.h" namespace impala { @@ -85,6 +86,14 @@ class DateValue { /// Otherwise, return false. bool ToDaysSinceEpoch(int32_t* days) const WARN_UNUSED_RESULT; + /// Returns a DateValue converted from a DateVal. The caller must ensure the DateVal + /// does not represent a NULL. + static DateValue FromDateVal(const impala_udf::DateVal& udf_value); + + /// Returns a DateVal representation in the output variable. + /// Returns null if the DateValue instance doesn't have a valid date. + impala_udf::DateVal ToDateVal() const; + /// Constructors that parse from a date string. See DateParser for details about the /// date format. static DateValue Parse(const char* str, int len); http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/udf/udf.h ---------------------------------------------------------------------- diff --git a/be/src/udf/udf.h b/be/src/udf/udf.h index 62a1576..ac0e806 100644 --- a/be/src/udf/udf.h +++ b/be/src/udf/udf.h @@ -54,6 +54,7 @@ struct IntVal; struct BigIntVal; struct StringVal; struct TimestampVal; +struct DateVal; /// A FunctionContext is passed to every UDF/UDA and is the interface for the UDF to the /// rest of the system. It contains APIs to examine the system state, report errors and @@ -82,7 +83,8 @@ class FunctionContext { TYPE_DECIMAL, TYPE_VARCHAR, // A fixed-size buffer, passed as a StringVal. - TYPE_FIXED_UDA_INTERMEDIATE + TYPE_FIXED_UDA_INTERMEDIATE, + TYPE_DATE }; struct TypeDesc { @@ -700,8 +702,30 @@ struct DecimalVal : public impala_udf::AnyVal { } }; +/// Date value represented as days since epoch 1970-01-01. +struct DateVal : public AnyVal { + typedef int32_t underlying_type_t; + underlying_type_t val; + + DateVal(underlying_type_t val = 0) : val(val) { } + + static DateVal null() { + DateVal result; + result.is_null = true; + return result; + } + + bool operator==(const DateVal& other) const { + if (is_null && other.is_null) return true; + if (is_null || other.is_null) return false; + return val == other.val; + } + bool operator!=(const DateVal& other) const { return !(*this == other); } +}; + typedef uint8_t* BufferVal; } #endif + http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/be/src/util/symbols-util.cc ---------------------------------------------------------------------- diff --git a/be/src/util/symbols-util.cc b/be/src/util/symbols-util.cc index 173143c..8bf3005 100644 --- a/be/src/util/symbols-util.cc +++ b/be/src/util/symbols-util.cc @@ -152,6 +152,9 @@ static void AppendAnyValType(int namespace_id, const ColumnType& type, stringstr case TYPE_DECIMAL: AppendMangledToken("DecimalVal", s); break; + case TYPE_DATE: + AppendMangledToken("DateVal", s); + break; default: DCHECK(false) << "NYI: " << type.DebugString(); } http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/fe/src/main/java/org/apache/impala/catalog/Function.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/Function.java b/fe/src/main/java/org/apache/impala/catalog/Function.java index e0c98be..ac0c9a6 100644 --- a/fe/src/main/java/org/apache/impala/catalog/Function.java +++ b/fe/src/main/java/org/apache/impala/catalog/Function.java @@ -492,6 +492,8 @@ public class Function extends CatalogObjectImpl { return "TimestampVal"; case DECIMAL: return "DecimalVal"; + case DATE: + return "DateVal"; default: Preconditions.checkState(false, t.toString()); return ""; http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/fe/src/main/java/org/apache/impala/catalog/ScalarFunction.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/ScalarFunction.java b/fe/src/main/java/org/apache/impala/catalog/ScalarFunction.java index 9b4fa68..d609f0f 100644 --- a/fe/src/main/java/org/apache/impala/catalog/ScalarFunction.java +++ b/fe/src/main/java/org/apache/impala/catalog/ScalarFunction.java @@ -203,6 +203,9 @@ public class ScalarFunction extends Function { beFn += "_DecimalVal"; usesDecimal = true; break; + case DATE: + beFn += "_DateVal"; + break; default: Preconditions.checkState(false, "Argument type not supported: " + argTypes.get(i).toSql()); http://git-wip-us.apache.org/repos/asf/impala/blob/cfc448db/fe/src/main/java/org/apache/impala/catalog/Type.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/Type.java b/fe/src/main/java/org/apache/impala/catalog/Type.java index 664fca1..65a5353 100644 --- a/fe/src/main/java/org/apache/impala/catalog/Type.java +++ b/fe/src/main/java/org/apache/impala/catalog/Type.java @@ -107,10 +107,10 @@ public abstract class Type { supportedTypes.add(CHAR); supportedTypes.add(TIMESTAMP); supportedTypes.add(DECIMAL); + supportedTypes.add(DATE); unsupportedTypes = Lists.newArrayList(); unsupportedTypes.add(BINARY); - unsupportedTypes.add(DATE); unsupportedTypes.add(DATETIME); }
