This is an automated email from the ASF dual-hosted git repository.
stigahuang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/impala.git
The following commit(s) were added to refs/heads/master by this push:
new a5f6c26 IMPALA-2536: Make ColumnType constructor explicit
a5f6c26 is described below
commit a5f6c26044420498ea2e23f143dbef27243f2364
Author: Tim Armstrong <[email protected]>
AuthorDate: Sun Dec 27 23:10:12 2020 -0800
IMPALA-2536: Make ColumnType constructor explicit
This avoids accidental implicit type conversions from
the PrimitiveType enum, or worse, integer values via
the enum.
Testing:
Ran core tests.
Change-Id: I2fe1d5da051c10904605328607bea78565356ef3
Reviewed-on: http://gerrit.cloudera.org:8080/16906
Reviewed-by: Wenzhe Zhou <[email protected]>
Reviewed-by: Quanlong Huang <[email protected]>
Tested-by: Impala Public Jenkins <[email protected]>
---
be/src/benchmarks/hash-benchmark.cc | 2 +-
be/src/codegen/llvm-codegen-test.cc | 2 +-
be/src/exec/grouping-aggregator.cc | 2 +-
be/src/exec/hash-table-test.cc | 6 +-
be/src/exec/hash-table.cc | 2 +-
be/src/exec/hdfs-scanner.cc | 3 +-
be/src/exprs/case-expr.cc | 3 +-
be/src/exprs/compound-predicates.cc | 6 +-
be/src/exprs/expr-test.cc | 192 +++++++++++++++------------
be/src/exprs/is-not-empty-predicate.cc | 8 +-
be/src/exprs/null-literal.h | 2 +-
be/src/exprs/valid-tuple-id.cc | 2 +-
be/src/runtime/buffered-tuple-stream-test.cc | 4 +-
be/src/runtime/data-stream-test.cc | 5 +-
be/src/runtime/date-test.cc | 8 +-
be/src/runtime/krpc-data-stream-mgr.cc | 8 +-
be/src/runtime/raw-value-test.cc | 87 ++++++------
be/src/runtime/row-batch-serialize-test.cc | 16 +--
be/src/runtime/timestamp-test.cc | 8 +-
be/src/runtime/types.h | 2 +-
be/src/service/hs2-util.cc | 7 +-
be/src/testutil/desc-tbl-builder.h | 4 +
be/src/util/avro-util.cc | 14 +-
be/src/util/symbols-util-test.cc | 42 +++---
24 files changed, 244 insertions(+), 191 deletions(-)
diff --git a/be/src/benchmarks/hash-benchmark.cc
b/be/src/benchmarks/hash-benchmark.cc
index 75f620b..562b52f 100644
--- a/be/src/benchmarks/hash-benchmark.cc
+++ b/be/src/benchmarks/hash-benchmark.cc
@@ -442,7 +442,7 @@ llvm::Function* CodegenCrcHash(LlvmCodeGen* codegen, bool
mixed) {
llvm::Value* string_data =
builder.CreateGEP(data, codegen->GetI32Constant(fixed_byte_size));
llvm::Value* string_val = builder.CreateBitCast(string_data,
- codegen->GetSlotPtrType(TYPE_STRING));
+ codegen->GetSlotPtrType(ColumnType(TYPE_STRING)));
llvm::Value* str_ptr = builder.CreateStructGEP(NULL, string_val, 0);
llvm::Value* str_len = builder.CreateStructGEP(NULL, string_val, 1);
str_ptr = builder.CreateLoad(str_ptr);
diff --git a/be/src/codegen/llvm-codegen-test.cc
b/be/src/codegen/llvm-codegen-test.cc
index bd5a247..466090f 100644
--- a/be/src/codegen/llvm-codegen-test.cc
+++ b/be/src/codegen/llvm-codegen-test.cc
@@ -315,7 +315,7 @@ TEST_F(LlvmCodeGenTest, ReplaceFnCall) {
// }
llvm::Function* CodegenStringTest(LlvmCodeGen* codegen) {
llvm::PointerType* string_val_ptr_type =
- codegen->GetSlotPtrType(TYPE_STRING);
+ codegen->GetSlotPtrType(ColumnType(TYPE_STRING));
EXPECT_TRUE(string_val_ptr_type != NULL);
LlvmCodeGen::FnPrototype prototype(codegen, "StringTest",
codegen->i32_type());
diff --git a/be/src/exec/grouping-aggregator.cc
b/be/src/exec/grouping-aggregator.cc
index b391893..93fc4ab 100644
--- a/be/src/exec/grouping-aggregator.cc
+++ b/be/src/exec/grouping-aggregator.cc
@@ -104,7 +104,7 @@ Status GroupingAggregatorConfig::Init(
// Hack to avoid TYPE_NULL SlotRefs.
SlotRef* build_expr = state->obj_pool()->Add(desc->type().type !=
TYPE_NULL ?
new SlotRef(desc) :
- new SlotRef(desc, TYPE_BOOLEAN));
+ new SlotRef(desc, ColumnType(TYPE_BOOLEAN)));
build_exprs_.push_back(build_expr);
// Not an entry point because all hash table callers support codegen.
RETURN_IF_ERROR(
diff --git a/be/src/exec/hash-table-test.cc b/be/src/exec/hash-table-test.cc
index 2a0c1ec..456c0f8 100644
--- a/be/src/exec/hash-table-test.cc
+++ b/be/src/exec/hash-table-test.cc
@@ -79,14 +79,16 @@ class HashTableTest : public testing::Test {
// Not very easy to test complex tuple layouts so this test will use the
// simplest. The purpose of these tests is to exercise the hash map
// internals so a simple build/probe expr is fine.
- ScalarExpr* build_expr = pool_.Add(new SlotRef(TYPE_INT, 1, true /*
nullable */));
+ ScalarExpr* build_expr =
+ pool_.Add(new SlotRef(ColumnType(TYPE_INT), 1, true /* nullable */));
ASSERT_OK(build_expr->Init(desc, true, nullptr));
build_exprs_.push_back(build_expr);
ASSERT_OK(ScalarExprEvaluator::Create(build_exprs_, nullptr, &pool_,
&mem_pool_,
&mem_pool_, &build_expr_evals_));
ASSERT_OK(ScalarExprEvaluator::Open(build_expr_evals_, nullptr));
- ScalarExpr* probe_expr = pool_.Add(new SlotRef(TYPE_INT, 1, true /*
nullable */));
+ ScalarExpr* probe_expr =
+ pool_.Add(new SlotRef(ColumnType(TYPE_INT), 1, true /* nullable */));
ASSERT_OK(probe_expr->Init(desc, true, nullptr));
probe_exprs_.push_back(probe_expr);
ASSERT_OK(ScalarExprEvaluator::Create(probe_exprs_, nullptr, &pool_,
&mem_pool_,
diff --git a/be/src/exec/hash-table.cc b/be/src/exec/hash-table.cc
index 2e1060c..4605989 100644
--- a/be/src/exec/hash-table.cc
+++ b/be/src/exec/hash-table.cc
@@ -1056,7 +1056,7 @@ Status HashTableCtx::CodegenHashRow(LlvmCodeGen* codegen,
bool use_murmur,
// Convert expr_values_buffer_ loc to llvm value
llvm::Value* str_val = builder.CreatePointerCast(
- llvm_loc, codegen->GetSlotPtrType(TYPE_STRING), "str_val");
+ llvm_loc, codegen->GetSlotPtrType(ColumnType(TYPE_STRING)),
"str_val");
llvm::Value* ptr = builder.CreateStructGEP(NULL, str_val, 0);
llvm::Value* len = builder.CreateStructGEP(NULL, str_val, 1);
diff --git a/be/src/exec/hdfs-scanner.cc b/be/src/exec/hdfs-scanner.cc
index 028957d..ec9f644 100644
--- a/be/src/exec/hdfs-scanner.cc
+++ b/be/src/exec/hdfs-scanner.cc
@@ -539,7 +539,8 @@ Status HdfsScanner::CodegenWriteCompleteTuple(const
HdfsScanPlanNode* node,
llvm::Value* conjunct_args[] = {eval, tuple_row_arg};
CodegenAnyVal result = CodegenAnyVal::CreateCallWrapped(
- codegen, &builder, TYPE_BOOLEAN, conjunct_fn, conjunct_args,
"conjunct_eval");
+ codegen, &builder, ColumnType(TYPE_BOOLEAN), conjunct_fn,
conjunct_args,
+ "conjunct_eval");
builder.CreateCondBr(result.GetVal(), parse_block, eval_fail_block);
builder.SetInsertPoint(parse_block);
}
diff --git a/be/src/exprs/case-expr.cc b/be/src/exprs/case-expr.cc
index 1aa9975..4698972 100644
--- a/be/src/exprs/case-expr.cc
+++ b/be/src/exprs/case-expr.cc
@@ -57,7 +57,8 @@ Status
CaseExpr::OpenEvaluator(FunctionContext::FunctionStateScope scope,
}
fn_ctx->SetFunctionState(FunctionContext::THREAD_LOCAL, case_state);
- const ColumnType& case_val_type = has_case_expr_ ? GetChild(0)->type() :
TYPE_BOOLEAN;
+ const ColumnType& case_val_type = has_case_expr_ ? GetChild(0)->type()
+ : ColumnType(TYPE_BOOLEAN);
RETURN_IF_ERROR(AllocateAnyVal(state, eval->expr_perm_pool(), case_val_type,
"Could not allocate expression value", &case_state->case_val));
const ColumnType& when_val_type =
diff --git a/be/src/exprs/compound-predicates.cc
b/be/src/exprs/compound-predicates.cc
index 7b5f516..5462cdf 100644
--- a/be/src/exprs/compound-predicates.cc
+++ b/be/src/exprs/compound-predicates.cc
@@ -154,10 +154,10 @@ Status CompoundPredicate::CodegenComputeFn(
// Call lhs
CodegenAnyVal lhs_result = CodegenAnyVal::CreateCallWrapped(
- codegen, &builder, TYPE_BOOLEAN, lhs_function, args, "lhs_call");
+ codegen, &builder, ColumnType(TYPE_BOOLEAN), lhs_function, args,
"lhs_call");
// Call rhs
CodegenAnyVal rhs_result = CodegenAnyVal::CreateCallWrapped(
- codegen, &builder, TYPE_BOOLEAN, rhs_function, args, "rhs_call");
+ codegen, &builder, ColumnType(TYPE_BOOLEAN), rhs_function, args,
"rhs_call");
llvm::Value* lhs_is_null = lhs_result.GetIsNull();
llvm::Value* rhs_is_null = rhs_result.GetIsNull();
@@ -231,7 +231,7 @@ Status CompoundPredicate::CodegenComputeFn(
val_phi->addIncoming(codegen->false_value(), null_block);
val_phi->addIncoming(not_null_phi, not_null_block);
- CodegenAnyVal ret(codegen, &builder, TYPE_BOOLEAN, NULL, "ret");
+ CodegenAnyVal ret(codegen, &builder, ColumnType(TYPE_BOOLEAN), NULL, "ret");
ret.SetIsNull(is_null_phi);
ret.SetVal(val_phi);
builder.CreateRet(ret.GetLoweredValue());
diff --git a/be/src/exprs/expr-test.cc b/be/src/exprs/expr-test.cc
index 024799b..58d98d0 100644
--- a/be/src/exprs/expr-test.cc
+++ b/be/src/exprs/expr-test.cc
@@ -365,7 +365,7 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
T ConvertValue(const string& value);
void TestStringValue(const string& expr, const string& expected_result) {
- EXPECT_EQ(expected_result, GetValue(expr, TYPE_STRING)) << expr;
+ EXPECT_EQ(expected_result, GetValue(expr, ColumnType(TYPE_STRING))) <<
expr;
}
// Tests that DST of the given timezone ends at 3am
@@ -378,7 +378,7 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
}
string TestStringValueRegex(const string& expr, const string& regex) {
- const string results = GetValue(expr, TYPE_STRING);
+ const string results = GetValue(expr, ColumnType(TYPE_STRING));
static const boost::regex e(regex);
const bool is_regex_match = regex_match(results, e);
EXPECT_TRUE(is_regex_match);
@@ -591,7 +591,7 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
} else {
typeof_query = "typeof(" + query + ")";
}
- const string typeof_result = GetValue(typeof_query, TYPE_STRING);
+ const string typeof_result = GetValue(typeof_query,
ColumnType(TYPE_STRING));
EXPECT_EQ(expected_type.DebugString(), typeof_result) << typeof_query;
}
@@ -627,6 +627,11 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
EXPECT_EQ(result, StringParser::PARSE_SUCCESS);
}
+ template <class T> void TestValue(const string& expr, PrimitiveType
expr_type,
+ const T& expected_result) {
+ return TestValue(expr, ColumnType(expr_type), expected_result);
+ }
+
template <class T> void TestValue(const string& expr, const ColumnType&
expr_type,
const T& expected_result) {
const string result = GetValue(expr, expr_type);
@@ -655,7 +660,7 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
float expected_float;
expected_float = static_cast<float>(expected_result);
RawValue::PrintValue(reinterpret_cast<const void*>(&expected_float),
- TYPE_FLOAT, -1, &expected_str);
+ ColumnType(TYPE_FLOAT), -1, &expected_str);
EXPECT_EQ(expected_str, result) << expr;
break;
}
@@ -664,7 +669,7 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
double expected_double;
expected_double = static_cast<double>(expected_result);
RawValue::PrintValue(reinterpret_cast<const void*>(&expected_double),
- TYPE_DOUBLE, -1, &expected_str);
+ ColumnType(TYPE_DOUBLE), -1, &expected_str);
EXPECT_EQ(expected_str, result) << expr;
break;
}
@@ -673,16 +678,24 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
}
}
+ void TestIsNull(const string& expr, PrimitiveType expr_type) {
+ return TestIsNull(expr, ColumnType(expr_type));
+ }
+
void TestIsNull(const string& expr, const ColumnType& expr_type) {
EXPECT_TRUE(GetValue(expr, expr_type) == "NULL") << expr;
}
+ void TestIsNotNull(const string& expr, PrimitiveType expr_type) {
+ return TestIsNotNull(expr, ColumnType(expr_type));
+ }
+
void TestIsNotNull(const string& expr, const ColumnType& expr_type) {
EXPECT_TRUE(GetValue(expr, expr_type) != "NULL") << expr;
}
void TestError(const string& expr) {
- GetValue(expr, INVALID_TYPE, /* expect_error */ true);
+ GetValue(expr, ColumnType(INVALID_TYPE), /* expect_error */ true);
}
void TestNonOkStatus(const string& expr) {
@@ -1152,12 +1165,16 @@ class ExprTest : public
testing::TestWithParam<std::tuple<bool, bool>> {
// Create a Literal expression out of 'str'. Adds the returned literal to
pool_.
Literal* CreateLiteral(const ColumnType& type, const string& str);
+ Literal* CreateLiteral(PrimitiveType type, const string& str);
// Helper function for LiteralConstruction test. Creates a Literal expression
// of 'type' from 'str' and verifies it compares equally to 'value'.
template <typename T>
void TestSingleLiteralConstruction(
const ColumnType& type, const T& value, const string& string_val);
+ template <typename T>
+ void TestSingleLiteralConstruction(
+ PrimitiveType type, const T& value, const string& string_val);
// Test casting stmt to all types. Expected result is val.
template<typename T>
@@ -1291,20 +1308,21 @@ DateValue ExprTest::ConvertValue<DateValue>(const
string& value) {
// the ambiguity in TimestampValue::operator==, even with the appropriate
casts.
void ExprTest::TestTimestampValue(const string& expr, const TimestampValue&
expected_result) {
EXPECT_EQ(expected_result,
- ConvertValue<TimestampValue>(GetValue(expr, TYPE_TIMESTAMP)));
+ ConvertValue<TimestampValue>(GetValue(expr,
ColumnType(TYPE_TIMESTAMP))));
}
// Tests whether the returned TimestampValue is valid.
// We use this function for tests where the expected value is unknown, e.g.,
now().
void ExprTest::TestValidTimestampValue(const string& expr) {
EXPECT_TRUE(
- ConvertValue<TimestampValue>(GetValue(expr, TYPE_TIMESTAMP)).HasDate());
+ ConvertValue<TimestampValue>(GetValue(expr,
ColumnType(TYPE_TIMESTAMP))).HasDate());
}
// We can't put this into TestValue() because GTest can't resolve
// the ambiguity in DateValue::operator==, even with the appropriate casts.
void ExprTest::TestDateValue(const string& expr, const DateValue&
expected_result) {
- EXPECT_EQ(expected_result, ConvertValue<DateValue>(GetValue(expr,
TYPE_DATE)));
+ EXPECT_EQ(expected_result,
+ ConvertValue<DateValue>(GetValue(expr, ColumnType(TYPE_DATE))));
}
template<class T>
@@ -1391,6 +1409,9 @@ Literal* ExprTest::CreateLiteral(const ColumnType& type,
const string& str) {
return nullptr;
}
}
+Literal* ExprTest::CreateLiteral(PrimitiveType type, const string& str) {
+ return CreateLiteral(ColumnType(type), str);
+}
template <typename T>
void ExprTest::TestSingleLiteralConstruction(
@@ -1413,6 +1434,12 @@ void ExprTest::TestSingleLiteralConstruction(
state.ReleaseResources();
}
+template <typename T>
+void ExprTest::TestSingleLiteralConstruction(
+ PrimitiveType type, const T& value, const string& string_val) {
+ return TestSingleLiteralConstruction(ColumnType(type), value, string_val);
+}
+
TEST_P(ExprTest, NullLiteral) {
for (int type = TYPE_BOOLEAN; type != TYPE_DATE; ++type) {
RuntimeState state(TQueryCtx(), ExecEnv::GetInstance());
@@ -1490,14 +1517,14 @@ TEST_P(ExprTest, LiteralConstruction) {
TEST_P(ExprTest, LiteralExprs) {
- TestFixedPointLimits<int8_t>(TYPE_TINYINT);
- TestFixedPointLimits<int16_t>(TYPE_SMALLINT);
- TestFixedPointLimits<int32_t>(TYPE_INT);
- TestFixedPointLimits<int64_t>(TYPE_BIGINT);
+ TestFixedPointLimits<int8_t>(ColumnType(TYPE_TINYINT));
+ TestFixedPointLimits<int16_t>(ColumnType(TYPE_SMALLINT));
+ TestFixedPointLimits<int32_t>(ColumnType(TYPE_INT));
+ TestFixedPointLimits<int64_t>(ColumnType(TYPE_BIGINT));
// The value is not an exact FLOAT so it gets compared as a DOUBLE
// and fails. This needs to be researched.
// TestFloatingPointLimits<float>(TYPE_FLOAT);
- TestFloatingPointLimits<double>(TYPE_DOUBLE);
+ TestFloatingPointLimits<double>(ColumnType(TYPE_DOUBLE));
TestValue("true", TYPE_BOOLEAN, true);
TestValue("false", TYPE_BOOLEAN, false);
@@ -1544,104 +1571,104 @@ TEST_P(ExprTest, EscapeStringLiteral) {
TEST_P(ExprTest, ArithmeticExprs) {
// Test float ops.
TestFixedResultTypeOps<float, float, double>(min_float_values_[TYPE_FLOAT],
- min_float_values_[TYPE_FLOAT], TYPE_DOUBLE);
+ min_float_values_[TYPE_FLOAT], ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<float, double, double>(min_float_values_[TYPE_FLOAT],
- min_float_values_[TYPE_DOUBLE], TYPE_DOUBLE);
+ min_float_values_[TYPE_DOUBLE], ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<double, double,
double>(min_float_values_[TYPE_DOUBLE],
- min_float_values_[TYPE_DOUBLE], TYPE_DOUBLE);
+ min_float_values_[TYPE_DOUBLE], ColumnType(TYPE_DOUBLE));
// Test behavior of float ops at max/min value boundaries.
// The tests with float type should trivially pass, since their results are
double.
TestFixedResultTypeOps<float, float, double>(numeric_limits<float>::min(),
- numeric_limits<float>::min(), TYPE_DOUBLE);
+ numeric_limits<float>::min(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<float, float, double>(numeric_limits<float>::max(),
- numeric_limits<float>::max(), TYPE_DOUBLE);
+ numeric_limits<float>::max(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<float, float, double>(numeric_limits<float>::min(),
- numeric_limits<float>::max(), TYPE_DOUBLE);
+ numeric_limits<float>::max(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<float, float, double>(numeric_limits<float>::max(),
- numeric_limits<float>::min(), TYPE_DOUBLE);
+ numeric_limits<float>::min(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<double, double, double>(numeric_limits<double>::min(),
- numeric_limits<double>::min(), TYPE_DOUBLE);
+ numeric_limits<double>::min(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<double, double, double>(numeric_limits<double>::max(),
- numeric_limits<double>::max(), TYPE_DOUBLE);
+ numeric_limits<double>::max(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<double, double, double>(numeric_limits<double>::min(),
- numeric_limits<double>::max(), TYPE_DOUBLE);
+ numeric_limits<double>::max(), ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<double, double, double>(numeric_limits<double>::max(),
- numeric_limits<double>::min(), TYPE_DOUBLE);
+ numeric_limits<double>::min(), ColumnType(TYPE_DOUBLE));
// Test behavior with zero (especially for division by zero).
TestFixedResultTypeOps<float, float, double>(min_float_values_[TYPE_FLOAT],
- 0.0f, TYPE_DOUBLE);
+ 0.0f, ColumnType(TYPE_DOUBLE));
TestFixedResultTypeOps<double, double,
double>(min_float_values_[TYPE_DOUBLE],
- 0.0, TYPE_DOUBLE);
+ 0.0, ColumnType(TYPE_DOUBLE));
// Test ops that always promote to fixed type (e.g., next higher resolution
type).
TestFixedResultTypeOps<int8_t, int8_t,
int16_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_TINYINT], TYPE_SMALLINT);
+ min_int_values_[TYPE_TINYINT], ColumnType(TYPE_SMALLINT));
TestFixedResultTypeOps<int8_t, int16_t,
int32_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_SMALLINT], TYPE_INT);
+ min_int_values_[TYPE_SMALLINT], ColumnType(TYPE_INT));
TestFixedResultTypeOps<int8_t, int32_t,
int64_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_INT], TYPE_BIGINT);
+ min_int_values_[TYPE_INT], ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int8_t, int64_t,
int64_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int16_t, int16_t,
int32_t>(min_int_values_[TYPE_SMALLINT],
- min_int_values_[TYPE_SMALLINT], TYPE_INT);
+ min_int_values_[TYPE_SMALLINT], ColumnType(TYPE_INT));
TestFixedResultTypeOps<int16_t, int32_t,
int64_t>(min_int_values_[TYPE_SMALLINT],
- min_int_values_[TYPE_INT], TYPE_BIGINT);
+ min_int_values_[TYPE_INT], ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int16_t, int64_t,
int64_t>(min_int_values_[TYPE_SMALLINT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int32_t, int32_t, int64_t>(min_int_values_[TYPE_INT],
- min_int_values_[TYPE_INT], TYPE_BIGINT);
+ min_int_values_[TYPE_INT], ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int32_t, int64_t, int64_t>(min_int_values_[TYPE_INT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int64_t, int64_t,
int64_t>(min_int_values_[TYPE_BIGINT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
// Test behavior on overflow/underflow.
TestFixedResultTypeOps<int64_t, int64_t,
int64_t>(numeric_limits<int64_t>::min()+1,
- numeric_limits<int64_t>::min()+1, TYPE_BIGINT);
+ numeric_limits<int64_t>::min()+1, ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int64_t, int64_t,
int64_t>(numeric_limits<int64_t>::max(),
- numeric_limits<int64_t>::max(), TYPE_BIGINT);
+ numeric_limits<int64_t>::max(), ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int64_t, int64_t,
int64_t>(numeric_limits<int64_t>::min()+1,
- numeric_limits<int64_t>::max(), TYPE_BIGINT);
+ numeric_limits<int64_t>::max(), ColumnType(TYPE_BIGINT));
TestFixedResultTypeOps<int64_t, int64_t,
int64_t>(numeric_limits<int64_t>::max(),
- numeric_limits<int64_t>::min()+1, TYPE_BIGINT);
+ numeric_limits<int64_t>::min()+1, ColumnType(TYPE_BIGINT));
// Test behavior with NULLs.
TestNullOperandFixedResultTypeOps<float,
double>(min_float_values_[TYPE_FLOAT],
- TYPE_DOUBLE);
+ ColumnType(TYPE_DOUBLE));
TestNullOperandFixedResultTypeOps<double,
double>(min_float_values_[TYPE_DOUBLE],
- TYPE_DOUBLE);
+ ColumnType(TYPE_DOUBLE));
TestNullOperandFixedResultTypeOps<int8_t,
int64_t>(min_int_values_[TYPE_TINYINT],
- TYPE_SMALLINT);
+ ColumnType(TYPE_SMALLINT));
TestNullOperandFixedResultTypeOps<int16_t,
int64_t>(min_int_values_[TYPE_SMALLINT],
- TYPE_INT);
+ ColumnType(TYPE_INT));
TestNullOperandFixedResultTypeOps<int32_t,
int64_t>(min_int_values_[TYPE_INT],
- TYPE_BIGINT);
+ ColumnType(TYPE_BIGINT));
TestNullOperandFixedResultTypeOps<int64_t,
int64_t>(min_int_values_[TYPE_BIGINT],
- TYPE_BIGINT);
+ ColumnType(TYPE_BIGINT));
// Test int ops that promote to assignment compatible type.
TestVariableResultTypeIntOps<int8_t, int8_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_TINYINT], TYPE_TINYINT);
+ min_int_values_[TYPE_TINYINT], ColumnType(TYPE_TINYINT));
TestVariableResultTypeIntOps<int8_t, int16_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_SMALLINT], TYPE_SMALLINT);
+ min_int_values_[TYPE_SMALLINT], ColumnType(TYPE_SMALLINT));
TestVariableResultTypeIntOps<int8_t, int32_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_INT], TYPE_INT);
+ min_int_values_[TYPE_INT], ColumnType(TYPE_INT));
TestVariableResultTypeIntOps<int8_t, int64_t>(min_int_values_[TYPE_TINYINT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
TestVariableResultTypeIntOps<int16_t,
int16_t>(min_int_values_[TYPE_SMALLINT],
- min_int_values_[TYPE_SMALLINT], TYPE_SMALLINT);
+ min_int_values_[TYPE_SMALLINT], ColumnType(TYPE_SMALLINT));
TestVariableResultTypeIntOps<int16_t,
int32_t>(min_int_values_[TYPE_SMALLINT],
- min_int_values_[TYPE_INT],TYPE_INT);
+ min_int_values_[TYPE_INT],ColumnType(TYPE_INT));
TestVariableResultTypeIntOps<int16_t,
int64_t>(min_int_values_[TYPE_SMALLINT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
TestVariableResultTypeIntOps<int32_t, int32_t>(min_int_values_[TYPE_INT],
- min_int_values_[TYPE_INT], TYPE_INT);
+ min_int_values_[TYPE_INT], ColumnType(TYPE_INT));
TestVariableResultTypeIntOps<int32_t, int64_t>(min_int_values_[TYPE_INT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
TestVariableResultTypeIntOps<int64_t, int64_t>(min_int_values_[TYPE_BIGINT],
- min_int_values_[TYPE_BIGINT], TYPE_BIGINT);
+ min_int_values_[TYPE_BIGINT], ColumnType(TYPE_BIGINT));
// Test behavior of INT_DIVIDE and MOD with zero as second argument.
IntValMap::iterator int_iter;
@@ -1654,13 +1681,13 @@ TEST_P(ExprTest, ArithmeticExprs) {
// Test behavior with NULLs.
TestNullOperandVariableResultTypeIntOps<int8_t>(min_int_values_[TYPE_TINYINT],
- TYPE_TINYINT);
+ ColumnType(TYPE_TINYINT));
TestNullOperandVariableResultTypeIntOps<int16_t>(min_int_values_[TYPE_SMALLINT],
- TYPE_SMALLINT);
+ ColumnType(TYPE_SMALLINT));
TestNullOperandVariableResultTypeIntOps<int32_t>(min_int_values_[TYPE_INT],
- TYPE_INT);
+ ColumnType(TYPE_INT));
TestNullOperandVariableResultTypeIntOps<int64_t>(min_int_values_[TYPE_BIGINT],
- TYPE_BIGINT);
+ ColumnType(TYPE_BIGINT));
// Tests for dealing with '-'.
TestValue("-1", TYPE_TINYINT, -1);
@@ -5509,8 +5536,8 @@ TEST_P(ExprTest, SessionFunctions) {
map<Session, map<Query, string>> results;
for (Session session: {S1, S2}) {
ASSERT_OK(executor_->Setup()); // Starts new session
- results[session][Q1] = GetValue("current_session()", TYPE_STRING);
- results[session][Q2] = GetValue("current_sid()", TYPE_STRING);
+ results[session][Q1] = GetValue("current_session()",
ColumnType(TYPE_STRING));
+ results[session][Q2] = GetValue("current_sid()", ColumnType(TYPE_STRING));
}
// The sessions IDs from the same session must be the same.
@@ -5934,7 +5961,7 @@ TEST_P(ExprTest, MathFunctions) {
rand << "rand(" << seed << ")";
random << "random(" << seed << ")";
const double expected_result = ConvertValue<double>(GetValue(rand.str(),
- TYPE_DOUBLE));
+ ColumnType(TYPE_DOUBLE)));
TestValue(rand.str(), TYPE_DOUBLE, expected_result);
TestValue(random.str(), TYPE_DOUBLE, expected_result); // Test alias
}
@@ -7022,7 +7049,7 @@ TEST_P(ExprTest, TimestampFunctions) {
time_t unix_start_time =
(posix_time::microsec_clock::local_time() -
from_time_t(0)).total_seconds();
int64_t unix_timestamp_result =
ConvertValue<int64_t>(GetValue("unix_timestamp()",
- TYPE_BIGINT));
+ ColumnType(TYPE_BIGINT)));
EXPECT_BETWEEN(unix_start_time, unix_timestamp_result,
static_cast<int64_t>(
(posix_time::microsec_clock::local_time() -
from_time_t(0)).total_seconds()));
@@ -7033,7 +7060,7 @@ TEST_P(ExprTest, TimestampFunctions) {
tm before = to_tm(posix_time::microsec_clock::local_time());
unix_start_time = mktime(&before);
unix_timestamp_result =
ConvertValue<int64_t>(GetValue("unix_timestamp()",
- TYPE_BIGINT));
+ ColumnType(TYPE_BIGINT)));
tm after = to_tm(posix_time::microsec_clock::local_time());
EXPECT_BETWEEN(unix_start_time, unix_timestamp_result,
static_cast<int64_t>(mktime(&after)));
@@ -7050,11 +7077,11 @@ TEST_P(ExprTest, TimestampFunctions) {
const TimestampValue start_time =
TimestampValue::FromUnixTimeMicros(UnixMicros(), &local_tz);
TimestampValue timestamp_result =
- ConvertValue<TimestampValue>(GetValue("now()", TYPE_TIMESTAMP));
+ ConvertValue<TimestampValue>(GetValue("now()",
ColumnType(TYPE_TIMESTAMP)));
EXPECT_BETWEEN(start_time, timestamp_result,
TimestampValue::FromUnixTimeMicros(UnixMicros(), &local_tz));
timestamp_result =
ConvertValue<TimestampValue>(GetValue("current_timestamp()",
- TYPE_TIMESTAMP));
+ ColumnType(TYPE_TIMESTAMP)));
EXPECT_BETWEEN(start_time, timestamp_result,
TimestampValue::FromUnixTimeMicros(UnixMicros(), &local_tz));
}
@@ -7062,8 +7089,8 @@ TEST_P(ExprTest, TimestampFunctions) {
// Test that utc_timestamp() is reasonable.
const TimestampValue utc_start_time =
TimestampValue::UtcFromUnixTimeMicros(UnixMicros());
- TimestampValue timestamp_result =
- ConvertValue<TimestampValue>(GetValue("utc_timestamp()",
TYPE_TIMESTAMP));
+ TimestampValue timestamp_result = ConvertValue<TimestampValue>(
+ GetValue("utc_timestamp()", ColumnType(TYPE_TIMESTAMP)));
EXPECT_BETWEEN(utc_start_time, timestamp_result,
TimestampValue::UtcFromUnixTimeMicros(UnixMicros()));
@@ -7079,7 +7106,7 @@ TEST_P(ExprTest, TimestampFunctions) {
time_t unix_start_time =
(posix_time::microsec_clock::local_time() -
from_time_t(0)).total_seconds();
TimestampValue timestamp_result = ConvertValue<TimestampValue>(GetValue(
- "cast(unix_timestamp() as timestamp)", TYPE_TIMESTAMP));
+ "cast(unix_timestamp() as timestamp)", ColumnType(TYPE_TIMESTAMP)));
EXPECT_BETWEEN(TimestampValue::FromUnixTime(unix_start_time - 1,
&local_tz),
timestamp_result,
TimestampValue::FromUnixTimeMicros(UnixMicros(), &local_tz));
@@ -8229,7 +8256,8 @@ TEST_P(ExprTest, DateFunctions) {
const boost::gregorian::date start_date =
TimestampValue::FromUnixTimeMicros(UnixMicros(), &local_tz).date();
- DateValue current_dv = ConvertValue<DateValue>(GetValue("current_date()",
TYPE_DATE));
+ DateValue current_dv =
+ ConvertValue<DateValue>(GetValue("current_date()",
ColumnType(TYPE_DATE)));
const boost::gregorian::date end_date =
TimestampValue::FromUnixTimeMicros(UnixMicros(), &local_tz).date();
@@ -8681,16 +8709,16 @@ TEST_P(ExprTest, ResultsLayoutTest) {
// Test single Expr case
vector<ColumnType> types;
- types.push_back(TYPE_BOOLEAN);
- types.push_back(TYPE_TINYINT);
- types.push_back(TYPE_SMALLINT);
- types.push_back(TYPE_INT);
- types.push_back(TYPE_BIGINT);
- types.push_back(TYPE_FLOAT);
- types.push_back(TYPE_DOUBLE);
- types.push_back(TYPE_TIMESTAMP);
- types.push_back(TYPE_DATE);
- types.push_back(TYPE_STRING);
+ types.push_back(ColumnType(TYPE_BOOLEAN));
+ types.push_back(ColumnType(TYPE_TINYINT));
+ types.push_back(ColumnType(TYPE_SMALLINT));
+ types.push_back(ColumnType(TYPE_INT));
+ types.push_back(ColumnType(TYPE_BIGINT));
+ types.push_back(ColumnType(TYPE_FLOAT));
+ types.push_back(ColumnType(TYPE_DOUBLE));
+ types.push_back(ColumnType(TYPE_TIMESTAMP));
+ types.push_back(ColumnType(TYPE_DATE));
+ types.push_back(ColumnType(TYPE_STRING));
types.push_back(ColumnType::CreateDecimalType(1,0));
types.push_back(ColumnType::CreateDecimalType(8,0));
diff --git a/be/src/exprs/is-not-empty-predicate.cc
b/be/src/exprs/is-not-empty-predicate.cc
index 7627fdd..f39ea98 100644
--- a/be/src/exprs/is-not-empty-predicate.cc
+++ b/be/src/exprs/is-not-empty-predicate.cc
@@ -111,8 +111,10 @@ Status IsNotEmptyPredicate::GetCodegendComputeFnImpl(
// Add code to the block that is executed if is_null was true.
builder.SetInsertPoint(ret_null);
// allocate a BooleanVal, set null in it, and return it.
- CodegenAnyVal null_result(codegen, &builder, TYPE_BOOLEAN, nullptr,
"null_result");
- builder.CreateRet(null_result.GetNullVal(codegen, TYPE_BOOLEAN));
+ CodegenAnyVal null_result(
+ codegen, &builder, ColumnType(TYPE_BOOLEAN), nullptr, "null_result");
+ builder.CreateRet(
+ null_result.GetNullVal(codegen, ColumnType(TYPE_BOOLEAN)));
// Back to the branch where 'is_null' is false.
builder.SetInsertPoint(check_count);
@@ -121,7 +123,7 @@ Status IsNotEmptyPredicate::GetCodegendComputeFnImpl(
llvm::Value* has_values = builder.CreateICmpNE(num_tuples,
codegen->GetI32Constant(0));
CodegenAnyVal has_values_result(
- codegen, &builder, TYPE_BOOLEAN, nullptr, "has_values_result");
+ codegen, &builder, ColumnType(TYPE_BOOLEAN), nullptr,
"has_values_result");
has_values_result.SetVal(has_values);
builder.CreateRet(has_values_result.GetLoweredValue());
diff --git a/be/src/exprs/null-literal.h b/be/src/exprs/null-literal.h
index a1e3956..c25c161 100644
--- a/be/src/exprs/null-literal.h
+++ b/be/src/exprs/null-literal.h
@@ -46,7 +46,7 @@ class NullLiteral: public ScalarExpr {
virtual std::string DebugString() const override;
/// Constructor for test.
- NullLiteral(PrimitiveType type) : ScalarExpr(type, true) { }
+ NullLiteral(PrimitiveType type) : ScalarExpr(ColumnType(type), true) { }
static const char* LLVM_CLASS_NAME;
diff --git a/be/src/exprs/valid-tuple-id.cc b/be/src/exprs/valid-tuple-id.cc
index e6fe640..dbfab49 100644
--- a/be/src/exprs/valid-tuple-id.cc
+++ b/be/src/exprs/valid-tuple-id.cc
@@ -147,7 +147,7 @@ Status ValidTupleIdExpr::GetCodegendComputeFnImpl(
// Add code to the block that is executed if the Tuple* was not a nullptr.
builder.SetInsertPoint(ret_block);
// Generate code returning an IntVal containing the tuple id.
- CodegenAnyVal result(codegen, &builder, TYPE_INT, nullptr, "ret");
+ CodegenAnyVal result(codegen, &builder, ColumnType(TYPE_INT), nullptr,
"ret");
llvm::Constant* tuple_id =
codegen->GetI32Constant(static_cast<uint64_t>(tuple_ids_[i]));
result.SetVal(tuple_id);
diff --git a/be/src/runtime/buffered-tuple-stream-test.cc
b/be/src/runtime/buffered-tuple-stream-test.cc
index 776b207..2a0d607 100644
--- a/be/src/runtime/buffered-tuple-stream-test.cc
+++ b/be/src/runtime/buffered-tuple-stream-test.cc
@@ -551,11 +551,11 @@ class ArrayTupleStreamTest : public SimpleTupleStreamTest
{
tuple_ids.push_back(static_cast<TTupleId>(1));
ColumnType string_array_type;
string_array_type.type = TYPE_ARRAY;
- string_array_type.children.push_back(TYPE_STRING);
+ string_array_type.children.push_back(ColumnType(TYPE_STRING));
ColumnType int_array_type;
int_array_type.type = TYPE_ARRAY;
- int_array_type.children.push_back(TYPE_STRING);
+ int_array_type.children.push_back(ColumnType(TYPE_STRING));
ColumnType nested_array_type;
nested_array_type.type = TYPE_ARRAY;
diff --git a/be/src/runtime/data-stream-test.cc
b/be/src/runtime/data-stream-test.cc
index d7f94a9..ec61d5e 100644
--- a/be/src/runtime/data-stream-test.cc
+++ b/be/src/runtime/data-stream-test.cc
@@ -168,7 +168,7 @@ class DataStreamTest : public testing::Test {
CreateRowDesc();
- SlotRef* lhs_slot = obj_pool_.Add(new SlotRef(TYPE_BIGINT, 0));
+ SlotRef* lhs_slot = obj_pool_.Add(new SlotRef(ColumnType(TYPE_BIGINT), 0));
ASSERT_OK(lhs_slot->Init(RowDescriptor(), true, fragment_state_));
ordering_exprs_.push_back(lhs_slot);
@@ -487,7 +487,8 @@ class DataStreamTest : public testing::Test {
} else if (stream_type == TPartitionType::HASH_PARTITIONED) {
// hash-partitioned streams send values to the right partition
int64_t value = *j;
- uint64_t hash_val = RawValue::GetHashValueFastHash(&value,
TYPE_BIGINT,
+ uint64_t hash_val = RawValue::GetHashValueFastHash(
+ &value, ColumnType(TYPE_BIGINT),
GetExchangeHashSeed(runtime_state_->query_id()));
EXPECT_EQ(hash_val % receiver_info_.size(), info->receiver_num);
}
diff --git a/be/src/runtime/date-test.cc b/be/src/runtime/date-test.cc
index 18d65c0..d6fc55a 100644
--- a/be/src/runtime/date-test.cc
+++ b/be/src/runtime/date-test.cc
@@ -74,10 +74,10 @@ TEST(DateTest, ParseDefault) {
EXPECT_EQ(v3, v4);
EXPECT_EQ(v3, v5);
- EXPECT_NE(RawValue::GetHashValue(&v1, TYPE_DATE, 0),
- RawValue::GetHashValue(&v2, TYPE_DATE, 0));
- EXPECT_EQ(RawValue::GetHashValue(&v3, TYPE_DATE, 0),
- RawValue::GetHashValue(&v2, TYPE_DATE, 0));
+ EXPECT_NE(RawValue::GetHashValue(&v1, ColumnType(TYPE_DATE), 0),
+ RawValue::GetHashValue(&v2, ColumnType(TYPE_DATE), 0));
+ EXPECT_EQ(RawValue::GetHashValue(&v3, ColumnType(TYPE_DATE), 0),
+ RawValue::GetHashValue(&v2, ColumnType(TYPE_DATE), 0));
// 1-digit months and days are ok in date string.
ParseValidateDate("2012-1-20", false, 2012, 1, 20);
diff --git a/be/src/runtime/krpc-data-stream-mgr.cc
b/be/src/runtime/krpc-data-stream-mgr.cc
index 0551a33..7e47fe5 100644
--- a/be/src/runtime/krpc-data-stream-mgr.cc
+++ b/be/src/runtime/krpc-data-stream-mgr.cc
@@ -95,9 +95,11 @@ Status KrpcDataStreamMgr::Init(MemTracker*
service_mem_tracker) {
inline uint32_t KrpcDataStreamMgr::GetHashValue(
const TUniqueId& fragment_instance_id, PlanNodeId dest_node_id) {
- uint32_t value = RawValue::GetHashValue(&fragment_instance_id.lo,
TYPE_BIGINT, 0);
- value = RawValue::GetHashValue(&fragment_instance_id.hi, TYPE_BIGINT, value);
- value = RawValue::GetHashValue(&dest_node_id, TYPE_INT, value);
+ uint32_t value = RawValue::GetHashValue(
+ &fragment_instance_id.lo, ColumnType(TYPE_BIGINT), 0);
+ value = RawValue::GetHashValue(
+ &fragment_instance_id.hi, ColumnType(TYPE_BIGINT), value);
+ value = RawValue::GetHashValue(&dest_node_id, ColumnType(TYPE_INT), value);
return value;
}
diff --git a/be/src/runtime/raw-value-test.cc b/be/src/runtime/raw-value-test.cc
index 0db8692..090178f 100644
--- a/be/src/runtime/raw-value-test.cc
+++ b/be/src/runtime/raw-value-test.cc
@@ -34,24 +34,24 @@ TEST_F(RawValueTest, Compare) {
int64_t v1, v2;
v1 = -2128609280;
v2 = 9223372036854775807;
- EXPECT_LT(RawValue::Compare(&v1, &v2, TYPE_BIGINT), 0);
- EXPECT_GT(RawValue::Compare(&v2, &v1, TYPE_BIGINT), 0);
+ EXPECT_LT(RawValue::Compare(&v1, &v2, ColumnType(TYPE_BIGINT)), 0);
+ EXPECT_GT(RawValue::Compare(&v2, &v1, ColumnType(TYPE_BIGINT)), 0);
int32_t i1, i2;
i1 = 2147483647;
i2 = -2147483640;
- EXPECT_GT(RawValue::Compare(&i1, &i2, TYPE_INT), 0);
- EXPECT_LT(RawValue::Compare(&i2, &i1, TYPE_INT), 0);
+ EXPECT_GT(RawValue::Compare(&i1, &i2, ColumnType(TYPE_INT)), 0);
+ EXPECT_LT(RawValue::Compare(&i2, &i1, ColumnType(TYPE_INT)), 0);
int16_t s1, s2;
s1 = 32767;
s2 = -32767;
- EXPECT_GT(RawValue::Compare(&s1, &s2, TYPE_SMALLINT), 0);
- EXPECT_LT(RawValue::Compare(&s2, &s1, TYPE_SMALLINT), 0);
+ EXPECT_GT(RawValue::Compare(&s1, &s2, ColumnType(TYPE_SMALLINT)), 0);
+ EXPECT_LT(RawValue::Compare(&s2, &s1, ColumnType(TYPE_SMALLINT)), 0);
DateValue d1(-719162), d2(719162);
- EXPECT_LT(RawValue::Compare(&d1, &d2, TYPE_DATE), 0);
- EXPECT_GT(RawValue::Compare(&d2, &d1, TYPE_DATE), 0);
+ EXPECT_LT(RawValue::Compare(&d1, &d2, ColumnType(TYPE_DATE)), 0);
+ EXPECT_GT(RawValue::Compare(&d2, &d1, ColumnType(TYPE_DATE)), 0);
}
TEST_F(RawValueTest, TypeChar) {
@@ -85,16 +85,19 @@ TEST_F(RawValueTest, TypeChar) {
// IMPALA-2270: "", false, and NULL should hash to distinct values.
TEST_F(RawValueTest, HashEmptyAndNull) {
uint32_t seed = 12345;
- uint32_t hash_null = RawValue::GetHashValue(nullptr, TYPE_STRING, seed);
- uint64_t fast_hash_null = RawValue::GetHashValueFastHash(nullptr,
TYPE_STRING, seed);
+ uint32_t hash_null =
+ RawValue::GetHashValue(nullptr, ColumnType(TYPE_STRING), seed);
+ uint64_t fast_hash_null =
+ RawValue::GetHashValueFastHash(nullptr, ColumnType(TYPE_STRING), seed);
StringValue empty(nullptr, 0);
- uint32_t hash_empty = RawValue::GetHashValue(&empty, TYPE_STRING, seed);
+ uint32_t hash_empty = RawValue::GetHashValue(&empty,
ColumnType(TYPE_STRING), seed);
uint64_t fast_hash_empty =
- RawValue::GetHashValueFastHash(&empty, TYPE_STRING, seed);
+ RawValue::GetHashValueFastHash(&empty, ColumnType(TYPE_STRING), seed);
bool false_val = false;
- uint32_t hash_false = RawValue::GetHashValue(&false_val, TYPE_BOOLEAN, seed);
+ uint32_t hash_false =
+ RawValue::GetHashValue(&false_val, ColumnType(TYPE_BOOLEAN), seed);
uint64_t fast_hash_false =
- RawValue::GetHashValueFastHash(&false_val, TYPE_BOOLEAN, seed);
+ RawValue::GetHashValueFastHash(&false_val, ColumnType(TYPE_BOOLEAN),
seed);
EXPECT_NE(seed, hash_null);
EXPECT_NE(seed, hash_empty);
EXPECT_NE(seed, hash_false);
@@ -113,9 +116,9 @@ TEST(HashUtil, IntNullSkew) {
int num_buckets = 16;
vector<int> buckets(num_buckets, 0);
for (int32_t i = 0; i < num_values; ++i) {
- uint64_t hash = RawValue::GetHashValueFastHash(&i, TYPE_INT, 9999);
+ uint64_t hash = RawValue::GetHashValueFastHash(&i, ColumnType(TYPE_INT),
9999);
StringValue empty(nullptr, 0);
- hash = RawValue::GetHashValueFastHash(&empty, TYPE_STRING, hash);
+ hash = RawValue::GetHashValueFastHash(&empty, ColumnType(TYPE_STRING),
hash);
++buckets[hash % num_buckets];
}
@@ -133,36 +136,43 @@ TEST_F(RawValueTest, TemplatizedHash) {
uint32_t seed = 12345;
int8_t tinyint_val = 8;
- EXPECT_EQ(RawValue::GetHashValue<int8_t>(&tinyint_val, TYPE_TINYINT, seed),
- RawValue::GetHashValue(&tinyint_val, TYPE_TINYINT, seed));
+ EXPECT_EQ(RawValue::GetHashValue<int8_t>(&tinyint_val,
ColumnType(TYPE_TINYINT), seed),
+ RawValue::GetHashValue(&tinyint_val, ColumnType(TYPE_TINYINT), seed));
int16_t smallint_val = 8;
- EXPECT_EQ(RawValue::GetHashValue<int16_t>(&smallint_val, TYPE_SMALLINT,
seed),
- RawValue::GetHashValue(&smallint_val, TYPE_SMALLINT, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<int16_t>(&smallint_val,
ColumnType(TYPE_SMALLINT), seed),
+ RawValue::GetHashValue(&smallint_val, ColumnType(TYPE_SMALLINT), seed));
int32_t int_val = 8;
- EXPECT_EQ(RawValue::GetHashValue<int32_t>(&int_val, TYPE_INT, seed),
- RawValue::GetHashValue(&int_val, TYPE_INT, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<int32_t>(&int_val, ColumnType(TYPE_INT), seed),
+ RawValue::GetHashValue(&int_val, ColumnType(TYPE_INT), seed));
int64_t bigint_val = 8;
- EXPECT_EQ(RawValue::GetHashValue<int64_t>(&bigint_val, TYPE_BIGINT, seed),
- RawValue::GetHashValue(&bigint_val, TYPE_BIGINT, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<int64_t>(&bigint_val, ColumnType(TYPE_BIGINT),
seed),
+ RawValue::GetHashValue(&bigint_val, ColumnType(TYPE_BIGINT), seed));
float float_val = 8.0f;
- EXPECT_EQ(RawValue::GetHashValue<float>(&float_val, TYPE_FLOAT, seed),
- RawValue::GetHashValue(&float_val, TYPE_FLOAT, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<float>(&float_val, ColumnType(TYPE_FLOAT), seed),
+ RawValue::GetHashValue(&float_val, ColumnType(TYPE_FLOAT), seed));
double double_val = 8.0;
- EXPECT_EQ(RawValue::GetHashValue<double>(&double_val, TYPE_DOUBLE, seed),
- RawValue::GetHashValue(&double_val, TYPE_DOUBLE, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<double>(&double_val, ColumnType(TYPE_DOUBLE),
seed),
+ RawValue::GetHashValue(&double_val, ColumnType(TYPE_DOUBLE), seed));
bool false_val = false;
- EXPECT_EQ(RawValue::GetHashValue<bool>(&false_val, TYPE_BOOLEAN, seed),
- RawValue::GetHashValue(&false_val, TYPE_BOOLEAN, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<bool>(&false_val, ColumnType(TYPE_BOOLEAN), seed),
+ RawValue::GetHashValue(&false_val, ColumnType(TYPE_BOOLEAN), seed));
bool true_val = true;
- EXPECT_EQ(RawValue::GetHashValue<bool>(&true_val, TYPE_BOOLEAN, seed),
- RawValue::GetHashValue(&true_val, TYPE_BOOLEAN, seed));
+ EXPECT_EQ(
+ RawValue::GetHashValue<bool>(&true_val, ColumnType(TYPE_BOOLEAN), seed),
+ RawValue::GetHashValue(&true_val, ColumnType(TYPE_BOOLEAN), seed));
StringValue string_value("aaaaa");
EXPECT_EQ(RawValue::GetHashValue<impala::StringValue>(
@@ -170,8 +180,8 @@ TEST_F(RawValueTest, TemplatizedHash) {
RawValue::GetHashValue(&string_value, ColumnType::CreateCharType(10),
seed));
EXPECT_EQ(RawValue::GetHashValue<impala::StringValue>(
- &string_value, TYPE_STRING, seed),
- RawValue::GetHashValue(&string_value, TYPE_STRING, seed));
+ &string_value, ColumnType(TYPE_STRING), seed),
+ RawValue::GetHashValue(&string_value, ColumnType(TYPE_STRING), seed));
EXPECT_EQ(RawValue::GetHashValue<impala::StringValue>(
&string_value, ColumnType::CreateVarcharType(
@@ -181,8 +191,8 @@ TEST_F(RawValueTest, TemplatizedHash) {
TimestampValue timestamp_value = TimestampValue::FromUnixTime(253433923200,
UTCPTR);
EXPECT_EQ(RawValue::GetHashValue<impala::TimestampValue>(
- ×tamp_value, TYPE_TIMESTAMP, seed),RawValue::GetHashValue(
- ×tamp_value, TYPE_TIMESTAMP, seed));
+ ×tamp_value, ColumnType(TYPE_TIMESTAMP), seed),RawValue::GetHashValue(
+ ×tamp_value, ColumnType(TYPE_TIMESTAMP), seed));
ColumnType d4_type = ColumnType::CreateDecimalType(9, 1);
Decimal4Value d4_value(123456789);
@@ -200,8 +210,9 @@ TEST_F(RawValueTest, TemplatizedHash) {
RawValue::GetHashValue(&d16_value, d16_type, seed));
DateValue date_value(1234567);
- EXPECT_EQ(RawValue::GetHashValue<impala::DateValue>(&date_value, TYPE_DATE,
seed),
- RawValue::GetHashValue(&date_value, TYPE_DATE, seed));
+ EXPECT_EQ(RawValue::GetHashValue<impala::DateValue>(
+ &date_value, ColumnType(TYPE_DATE), seed),
+ RawValue::GetHashValue(&date_value, ColumnType(TYPE_DATE), seed));
}
}
diff --git a/be/src/runtime/row-batch-serialize-test.cc
b/be/src/runtime/row-batch-serialize-test.cc
index a67da12..4b99b87 100644
--- a/be/src/runtime/row-batch-serialize-test.cc
+++ b/be/src/runtime/row-batch-serialize-test.cc
@@ -448,7 +448,7 @@ TEST_F(RowBatchSerializeTest, BasicArray) {
// tuple: (int, string, array<int>)
ColumnType array_type;
array_type.type = TYPE_ARRAY;
- array_type.children.push_back(TYPE_INT);
+ array_type.children.push_back(ColumnType(TYPE_INT));
DescriptorTblBuilder builder(frontend(), &pool_);
builder.DeclareTuple() << TYPE_INT << TYPE_STRING << array_type;
@@ -467,13 +467,13 @@ TEST_F(RowBatchSerializeTest, StringArray) {
// tuple: (int, string, array<struct<int, string, string>>)
ColumnType struct_type;
struct_type.type = TYPE_STRUCT;
- struct_type.children.push_back(TYPE_INT);
+ struct_type.children.push_back(ColumnType(TYPE_INT));
struct_type.field_names.push_back("int1");
struct_type.field_ids.push_back(-1);
- struct_type.children.push_back(TYPE_STRING);
+ struct_type.children.push_back(ColumnType(TYPE_STRING));
struct_type.field_names.push_back("string1");
struct_type.field_ids.push_back(-1);
- struct_type.children.push_back(TYPE_STRING);
+ struct_type.children.push_back(ColumnType(TYPE_STRING));
struct_type.field_names.push_back("string2");
struct_type.field_ids.push_back(-1);
@@ -498,14 +498,14 @@ TEST_F(RowBatchSerializeTest, NestedArrays) {
// tuple: (array<struct<array<string>, array<string, string>>>)
ColumnType inner_array_type1;
inner_array_type1.type = TYPE_ARRAY;
- inner_array_type1.children.push_back(TYPE_STRING);
+ inner_array_type1.children.push_back(ColumnType(TYPE_STRING));
ColumnType inner_struct_type;
inner_struct_type.type = TYPE_STRUCT;
- inner_struct_type.children.push_back(TYPE_STRING);
+ inner_struct_type.children.push_back(ColumnType(TYPE_STRING));
inner_struct_type.field_names.push_back("string1");
inner_struct_type.field_ids.push_back(-1);
- inner_struct_type.children.push_back(TYPE_STRING);
+ inner_struct_type.children.push_back(ColumnType(TYPE_STRING));
inner_struct_type.field_names.push_back("string2");
inner_struct_type.field_ids.push_back(-1);
@@ -684,7 +684,7 @@ TEST_F(RowBatchSerializeTest, DedupPathologicalFull) {
// Need 3 tuples + array to enable non-adjacent dedup automatically
ColumnType array_type;
array_type.type = TYPE_ARRAY;
- array_type.children.push_back(TYPE_STRING);
+ array_type.children.push_back(ColumnType(TYPE_STRING));
DescriptorTblBuilder builder(frontend(), &pool_);
builder.DeclareTuple() << TYPE_INT;
builder.DeclareTuple() << TYPE_INT;
diff --git a/be/src/runtime/timestamp-test.cc b/be/src/runtime/timestamp-test.cc
index 813380f..bbed2ea 100644
--- a/be/src/runtime/timestamp-test.cc
+++ b/be/src/runtime/timestamp-test.cc
@@ -356,10 +356,10 @@ TEST(TimestampTest, Basic) {
EXPECT_GT(v1, v2);
EXPECT_GE(v2, v3);
- EXPECT_NE(RawValue::GetHashValue(&v1, TYPE_TIMESTAMP, 0),
- RawValue::GetHashValue(&v2, TYPE_TIMESTAMP, 0));
- EXPECT_EQ(RawValue::GetHashValue(&v3, TYPE_TIMESTAMP, 0),
- RawValue::GetHashValue(&v2, TYPE_TIMESTAMP, 0));
+ EXPECT_NE(RawValue::GetHashValue(&v1, ColumnType(TYPE_TIMESTAMP), 0),
+ RawValue::GetHashValue(&v2, ColumnType(TYPE_TIMESTAMP), 0));
+ EXPECT_EQ(RawValue::GetHashValue(&v3, ColumnType(TYPE_TIMESTAMP), 0),
+ RawValue::GetHashValue(&v2, ColumnType(TYPE_TIMESTAMP), 0));
char s4[] = "2012-01-20T01:10:01";
char s5[] = "1990-10-20T10:10:10.123456789";
diff --git a/be/src/runtime/types.h b/be/src/runtime/types.h
index 49a097b..684c41e 100644
--- a/be/src/runtime/types.h
+++ b/be/src/runtime/types.h
@@ -97,7 +97,7 @@ struct ColumnType {
static const char* LLVM_CLASS_NAME;
- ColumnType(PrimitiveType type = INVALID_TYPE)
+ explicit ColumnType(PrimitiveType type = INVALID_TYPE)
: type(type), len(-1), precision(-1), scale(-1) {
DCHECK_NE(type, TYPE_CHAR);
DCHECK_NE(type, TYPE_VARCHAR);
diff --git a/be/src/service/hs2-util.cc b/be/src/service/hs2-util.cc
index e0baae1..01c7e2e 100644
--- a/be/src/service/hs2-util.cc
+++ b/be/src/service/hs2-util.cc
@@ -242,7 +242,7 @@ static void
TimestampExprValuesToHS2TColumn(ScalarExprEvaluator* expr_eval,
if (!val.is_null) {
TimestampValue value = TimestampValue::FromTimestampVal(val);
RawValue::PrintValue(
- &value, TYPE_TIMESTAMP, -1, &(column->stringVal.values.back()));
+ &value, ColumnType(TYPE_TIMESTAMP), -1,
&(column->stringVal.values.back()));
}
SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls);
++output_row_idx;
@@ -260,7 +260,7 @@ static void DateExprValuesToHS2TColumn(ScalarExprEvaluator*
expr_eval,
if (!val.is_null) {
DateValue value = DateValue::FromDateVal(val);
RawValue::PrintValue(
- &value, TYPE_DATE, -1, &(column->stringVal.values.back()));
+ &value, ColumnType(TYPE_DATE), -1,
&(column->stringVal.values.back()));
}
SetNullBit(output_row_idx, val.is_null, &column->stringVal.nulls);
++output_row_idx;
@@ -545,7 +545,8 @@ void impala::ExprValueToHS2TColumnValue(const void* value,
const TColumnType& ty
hs2_col_val->__isset.stringVal = true;
hs2_col_val->stringVal.__isset.value = not_null;
if (not_null) {
- RawValue::PrintValue(value, TYPE_TIMESTAMP, -1,
&(hs2_col_val->stringVal.value));
+ RawValue::PrintValue(
+ value, ColumnType(TYPE_TIMESTAMP), -1,
&(hs2_col_val->stringVal.value));
}
break;
case TPrimitiveType::DECIMAL: {
diff --git a/be/src/testutil/desc-tbl-builder.h
b/be/src/testutil/desc-tbl-builder.h
index 9d27092..f11ef6d 100644
--- a/be/src/testutil/desc-tbl-builder.h
+++ b/be/src/testutil/desc-tbl-builder.h
@@ -69,6 +69,10 @@ class TupleDescBuilder {
return *this;
}
+ TupleDescBuilder& operator<< (PrimitiveType slot_type) {
+ return *this << ColumnType(slot_type);
+ }
+
std::vector<ColumnType> slot_types() const { return slot_types_; }
private:
diff --git a/be/src/util/avro-util.cc b/be/src/util/avro-util.cc
index 5b4d6e0..b454890 100644
--- a/be/src/util/avro-util.cc
+++ b/be/src/util/avro-util.cc
@@ -109,25 +109,25 @@ Status AvroSchemaToColumnType(
switch (schema->type) {
case AVRO_BYTES:
case AVRO_STRING:
- *column_type = TYPE_STRING;
+ *column_type = ColumnType(TYPE_STRING);
return Status::OK();
case AVRO_INT32:
- *column_type = TYPE_INT;
+ *column_type = ColumnType(TYPE_INT);
return Status::OK();
case AVRO_DATE:
- *column_type = TYPE_DATE;
+ *column_type = ColumnType(TYPE_DATE);
return Status::OK();
case AVRO_INT64:
- *column_type = TYPE_BIGINT;
+ *column_type = ColumnType(TYPE_BIGINT);
return Status::OK();
case AVRO_FLOAT:
- *column_type = TYPE_FLOAT;
+ *column_type = ColumnType(TYPE_FLOAT);
return Status::OK();
case AVRO_DOUBLE:
- *column_type = TYPE_DOUBLE;
+ *column_type = ColumnType(TYPE_DOUBLE);
return Status::OK();
case AVRO_BOOLEAN:
- *column_type = TYPE_BOOLEAN;
+ *column_type = ColumnType(TYPE_BOOLEAN);
return Status::OK();
case AVRO_DECIMAL: {
int precision = avro_schema_decimal_precision(schema);
diff --git a/be/src/util/symbols-util-test.cc b/be/src/util/symbols-util-test.cc
index c6ced23..05c148f 100644
--- a/be/src/util/symbols-util-test.cc
+++ b/be/src/util/symbols-util-test.cc
@@ -142,7 +142,7 @@ TEST(SymbolsUtil, Mangling) {
"A::B::C(impala_udf::FunctionContext*, impala_udf::IntVal*)");
// Try functions with in input INT arg. Then try with varargs and int*
return arg.
- args.push_back(TYPE_INT);
+ args.push_back(ColumnType(TYPE_INT));
TestMangling("F", false, args, NULL,
"_Z1FPN10impala_udf15FunctionContextERKNS_6IntValE",
"F(impala_udf::FunctionContext*, impala_udf::IntVal const&)");
@@ -171,7 +171,7 @@ TEST(SymbolsUtil, Mangling) {
"impala_udf::IntVal*)");
// Try addding some redudant argument types. These should get compressed
away.
- args.push_back(TYPE_INT);
+ args.push_back(ColumnType(TYPE_INT));
TestMangling("F", false, args, NULL,
"_Z1FPN10impala_udf15FunctionContextERKNS_6IntValES4_",
"F(impala_udf::FunctionContext*, impala_udf::IntVal const&, "
@@ -193,7 +193,7 @@ TEST(SymbolsUtil, Mangling) {
"F::B(impala_udf::FunctionContext*, impala_udf::IntVal const&, "
"impala_udf::IntVal const&)");
- args.push_back(TYPE_INT);
+ args.push_back(ColumnType(TYPE_INT));
TestMangling("F", false, args, NULL,
"_Z1FPN10impala_udf15FunctionContextERKNS_6IntValES4_S4_",
"F(impala_udf::FunctionContext*, impala_udf::IntVal const&, "
@@ -212,10 +212,10 @@ TEST(SymbolsUtil, Mangling) {
// Try some more complicated cases.
// fn(double, double, int, int)
args.clear();
- args.push_back(TYPE_DOUBLE);
- args.push_back(TYPE_DOUBLE);
- args.push_back(TYPE_INT);
- args.push_back(TYPE_INT);
+ args.push_back(ColumnType(TYPE_DOUBLE));
+ args.push_back(ColumnType(TYPE_DOUBLE));
+ args.push_back(ColumnType(TYPE_INT));
+ args.push_back(ColumnType(TYPE_INT));
TestMangling("TEST", false, args, NULL,
"_Z4TESTPN10impala_udf15FunctionContextERKNS_9DoubleValES4_RKNS_6IntValES7_",
"TEST(impala_udf::FunctionContext*, impala_udf::DoubleVal const&, "
@@ -239,10 +239,10 @@ TEST(SymbolsUtil, Mangling) {
// fn(int, double, double, int)
args.clear();
- args.push_back(TYPE_INT);
- args.push_back(TYPE_DOUBLE);
- args.push_back(TYPE_DOUBLE);
- args.push_back(TYPE_INT);
+ args.push_back(ColumnType(TYPE_INT));
+ args.push_back(ColumnType(TYPE_DOUBLE));
+ args.push_back(ColumnType(TYPE_DOUBLE));
+ args.push_back(ColumnType(TYPE_INT));
TestMangling("TEST", false, args, NULL,
"_Z4TESTPN10impala_udf15FunctionContextERKNS_6IntValERKNS_9DoubleValES7_S4_",
"TEST(impala_udf::FunctionContext*, impala_udf::IntVal const&,
impala_udf::"
@@ -255,16 +255,16 @@ TEST(SymbolsUtil, Mangling) {
// All the types.
args.clear();
- args.push_back(TYPE_STRING);
- args.push_back(TYPE_BOOLEAN);
- args.push_back(TYPE_TINYINT);
- args.push_back(TYPE_SMALLINT);
- args.push_back(TYPE_INT);
- args.push_back(TYPE_BIGINT);
- args.push_back(TYPE_FLOAT);
- args.push_back(TYPE_DOUBLE);
- args.push_back(TYPE_TIMESTAMP);
- args.push_back(TYPE_DATE);
+ args.push_back(ColumnType(TYPE_STRING));
+ args.push_back(ColumnType(TYPE_BOOLEAN));
+ args.push_back(ColumnType(TYPE_TINYINT));
+ args.push_back(ColumnType(TYPE_SMALLINT));
+ args.push_back(ColumnType(TYPE_INT));
+ args.push_back(ColumnType(TYPE_BIGINT));
+ args.push_back(ColumnType(TYPE_FLOAT));
+ args.push_back(ColumnType(TYPE_DOUBLE));
+ args.push_back(ColumnType(TYPE_TIMESTAMP));
+ args.push_back(ColumnType(TYPE_DATE));
args.push_back(ColumnType::CreateCharType(10));
TestMangling("AllTypes", false, args, NULL,
"_Z8AllTypesPN10impala_udf15FunctionContextERKNS_9StringValERKNS_10BooleanValE"
