http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c123bd49/expressions/aggregation/tests/AggregationHandleMax_unittest.cpp ---------------------------------------------------------------------- diff --git a/expressions/aggregation/tests/AggregationHandleMax_unittest.cpp b/expressions/aggregation/tests/AggregationHandleMax_unittest.cpp index b7cf02a..026bd1d 100644 --- a/expressions/aggregation/tests/AggregationHandleMax_unittest.cpp +++ b/expressions/aggregation/tests/AggregationHandleMax_unittest.cpp @@ -31,6 +31,8 @@ #include "expressions/aggregation/AggregationHandle.hpp" #include "expressions/aggregation/AggregationHandleMax.hpp" #include "expressions/aggregation/AggregationID.hpp" +#include "storage/AggregationOperationState.hpp" +#include "storage/FastHashTableFactory.hpp" #include "storage/HashTableBase.hpp" #include "storage/StorageManager.hpp" #include "types/CharType.hpp" @@ -70,54 +72,59 @@ class AggregationHandleMaxTest : public ::testing::Test { // Helper method that calls AggregationHandleMax::iterateUnaryInl() to // aggregate 'value' into '*state'. void iterateHandle(AggregationState *state, const TypedValue &value) { - static_cast<const AggregationHandleMax&>(*aggregation_handle_max_).iterateUnaryInl( - static_cast<AggregationStateMax*>(state), - value); + static_cast<const AggregationHandleMax &>(*aggregation_handle_max_) + .iterateUnaryInl(static_cast<AggregationStateMax *>(state), value); } void initializeHandle(const Type &type) { aggregation_handle_max_.reset( - AggregateFunctionFactory::Get(AggregationID::kMax).createHandle( - std::vector<const Type*>(1, &type))); + AggregateFunctionFactory::Get(AggregationID::kMax) + .createHandle(std::vector<const Type *>(1, &type))); aggregation_handle_max_state_.reset( aggregation_handle_max_->createInitialState()); } static bool ApplyToTypesTest(TypeID typeID) { - const Type &type = (typeID == kChar || typeID == kVarChar) ? - TypeFactory::GetType(typeID, static_cast<std::size_t>(10)) : - TypeFactory::GetType(typeID); + const Type &type = + (typeID == kChar || typeID == kVarChar) + ? TypeFactory::GetType(typeID, static_cast<std::size_t>(10)) + : TypeFactory::GetType(typeID); - return AggregateFunctionFactory::Get(AggregationID::kMax).canApplyToTypes( - std::vector<const Type*>(1, &type)); + return AggregateFunctionFactory::Get(AggregationID::kMax) + .canApplyToTypes(std::vector<const Type *>(1, &type)); } static bool ResultTypeForArgumentTypeTest(TypeID input_type_id, TypeID output_type_id) { - const Type *result_type - = AggregateFunctionFactory::Get(AggregationID::kMax).resultTypeForArgumentTypes( - std::vector<const Type*>(1, &TypeFactory::GetType(input_type_id))); + const Type *result_type = + AggregateFunctionFactory::Get(AggregationID::kMax) + .resultTypeForArgumentTypes(std::vector<const Type *>( + 1, &TypeFactory::GetType(input_type_id))); return (result_type->getTypeID() == output_type_id); } template <typename CppType> - static void CheckMaxValue( - CppType expected, - const AggregationHandle &handle, - const AggregationState &state) { + static void CheckMaxValue(CppType expected, + const AggregationHandle &handle, + const AggregationState &state) { EXPECT_EQ(expected, handle.finalize(state).getLiteral<CppType>()); } - static void CheckMaxString( - const std::string &expected, - const AggregationHandle &handle, - const AggregationState &state) { + template <typename CppType> + static void CheckMaxValue(CppType expected, const TypedValue &value) { + EXPECT_EQ(expected, value.getLiteral<CppType>()); + } + + static void CheckMaxString(const std::string &expected, + const AggregationHandle &handle, + const AggregationState &state) { TypedValue value = handle.finalize(state); ASSERT_EQ(expected.length(), value.getAsciiStringLength()); - EXPECT_EQ(0, std::strncmp(expected.c_str(), - static_cast<const char*>(value.getDataPtr()), - value.getAsciiStringLength())); + EXPECT_EQ(0, + std::strncmp(expected.c_str(), + static_cast<const char *>(value.getDataPtr()), + value.getAsciiStringLength())); } // Static templated method to initialize data types. @@ -130,7 +137,9 @@ class AggregationHandleMaxTest : public ::testing::Test { void checkAggregationMaxGeneric() { const GenericType &type = GenericType::Instance(true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_max_->finalize(*aggregation_handle_max_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_max_->finalize(*aggregation_handle_max_state_) + .isNull()); typename GenericType::cpptype val; typename GenericType::cpptype max; @@ -142,16 +151,18 @@ class AggregationHandleMaxTest : public ::testing::Test { if (type.getTypeID() == kInt || type.getTypeID() == kLong) { SetDataType(i * kNumSamples + j - 10, &val); } else { - SetDataType(static_cast<float>(i * kNumSamples + j - 10)/10, &val); + SetDataType(static_cast<float>(i * kNumSamples + j - 10) / 10, &val); } - iterateHandle(aggregation_handle_max_state_.get(), type.makeValue(&val)); + iterateHandle(aggregation_handle_max_state_.get(), + type.makeValue(&val)); if (max < val) { max = val; } } } iterateHandle(aggregation_handle_max_state_.get(), type.makeNullValue()); - CheckMaxValue<typename GenericType::cpptype>(max, *aggregation_handle_max_, *aggregation_handle_max_state_); + CheckMaxValue<typename GenericType::cpptype>( + max, *aggregation_handle_max_, *aggregation_handle_max_state_); // Test mergeStates(). std::unique_ptr<AggregationState> merge_state( @@ -165,7 +176,7 @@ class AggregationHandleMaxTest : public ::testing::Test { if (type.getTypeID() == kInt || type.getTypeID() == kLong) { SetDataType(i * kNumSamples + j - 20, &val); } else { - SetDataType(static_cast<float>(i * kNumSamples + j - 20)/10, &val); + SetDataType(static_cast<float>(i * kNumSamples + j - 20) / 10, &val); } iterateHandle(merge_state.get(), type.makeValue(&val)); if (max < val) { @@ -176,14 +187,14 @@ class AggregationHandleMaxTest : public ::testing::Test { aggregation_handle_max_->mergeStates(*merge_state, aggregation_handle_max_state_.get()); CheckMaxValue<typename GenericType::cpptype>( - max, - *aggregation_handle_max_, - *aggregation_handle_max_state_); + max, *aggregation_handle_max_, *aggregation_handle_max_state_); } template <typename GenericType> - ColumnVector *createColumnVectorGeneric(const Type &type, typename GenericType::cpptype *max) { - NativeColumnVector *column = new NativeColumnVector(type, kIterations * kNumSamples + 3); + ColumnVector* createColumnVectorGeneric(const Type &type, + typename GenericType::cpptype *max) { + NativeColumnVector *column = + new NativeColumnVector(type, kIterations * kNumSamples + 3); typename GenericType::cpptype val; SetDataType(0, max); @@ -194,7 +205,7 @@ class AggregationHandleMaxTest : public ::testing::Test { if (type.getTypeID() == kInt || type.getTypeID() == kLong) { SetDataType(i * kNumSamples + j - 10, &val); } else { - SetDataType(static_cast<float>(i * kNumSamples + j - 10)/10, &val); + SetDataType(static_cast<float>(i * kNumSamples + j - 10) / 10, &val); } column->appendTypedValue(type.makeValue(&val)); if (*max < val) { @@ -202,7 +213,7 @@ class AggregationHandleMaxTest : public ::testing::Test { } } // One NULL in the middle. - if (i == kIterations/2) { + if (i == kIterations / 2) { column->appendTypedValue(type.makeNullValue()); } } @@ -215,11 +226,14 @@ class AggregationHandleMaxTest : public ::testing::Test { void checkAggregationMaxGenericColumnVector() { const GenericType &type = GenericType::Instance(true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_max_->finalize(*aggregation_handle_max_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_max_->finalize(*aggregation_handle_max_state_) + .isNull()); typename GenericType::cpptype max; std::vector<std::unique_ptr<ColumnVector>> column_vectors; - column_vectors.emplace_back(createColumnVectorGeneric<GenericType>(type, &max)); + column_vectors.emplace_back( + createColumnVectorGeneric<GenericType>(type, &max)); std::unique_ptr<AggregationState> cv_state( aggregation_handle_max_->accumulateColumnVectors(column_vectors)); @@ -227,15 +241,12 @@ class AggregationHandleMaxTest : public ::testing::Test { // Test the state generated directly by accumulateColumnVectors(), and also // test after merging back. CheckMaxValue<typename GenericType::cpptype>( - max, - *aggregation_handle_max_, - *cv_state); + max, *aggregation_handle_max_, *cv_state); - aggregation_handle_max_->mergeStates(*cv_state, aggregation_handle_max_state_.get()); + aggregation_handle_max_->mergeStates(*cv_state, + aggregation_handle_max_state_.get()); CheckMaxValue<typename GenericType::cpptype>( - max, - *aggregation_handle_max_, - *aggregation_handle_max_state_); + max, *aggregation_handle_max_, *aggregation_handle_max_state_); } #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -243,29 +254,29 @@ class AggregationHandleMaxTest : public ::testing::Test { void checkAggregationMaxGenericValueAccessor() { const GenericType &type = GenericType::Instance(true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_max_->finalize(*aggregation_handle_max_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_max_->finalize(*aggregation_handle_max_state_) + .isNull()); - std::unique_ptr<ColumnVectorsValueAccessor> accessor(new ColumnVectorsValueAccessor()); + std::unique_ptr<ColumnVectorsValueAccessor> accessor( + new ColumnVectorsValueAccessor()); typename GenericType::cpptype max; accessor->addColumn(createColumnVectorGeneric<GenericType>(type, &max)); std::unique_ptr<AggregationState> va_state( - aggregation_handle_max_->accumulateValueAccessor(accessor.get(), - std::vector<attribute_id>(1, 0))); + aggregation_handle_max_->accumulateValueAccessor( + accessor.get(), std::vector<attribute_id>(1, 0))); // Test the state generated directly by accumulateValueAccessor(), and also // test after merging back. CheckMaxValue<typename GenericType::cpptype>( - max, - *aggregation_handle_max_, - *va_state); + max, *aggregation_handle_max_, *va_state); - aggregation_handle_max_->mergeStates(*va_state, aggregation_handle_max_state_.get()); + aggregation_handle_max_->mergeStates(*va_state, + aggregation_handle_max_state_.get()); CheckMaxValue<typename GenericType::cpptype>( - max, - *aggregation_handle_max_, - *aggregation_handle_max_state_); + max, *aggregation_handle_max_, *aggregation_handle_max_state_); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -273,11 +284,14 @@ class AggregationHandleMaxTest : public ::testing::Test { void checkAggregationMaxString() { const StringType &type = StringType::Instance(10, true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_max_->finalize(*aggregation_handle_max_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_max_->finalize(*aggregation_handle_max_state_) + .isNull()); std::unique_ptr<UncheckedComparator> fast_comparator_; - fast_comparator_.reset(ComparisonFactory::GetComparison(ComparisonID::kGreater) - .makeUncheckedComparatorForTypes(type, type)); + fast_comparator_.reset( + ComparisonFactory::GetComparison(ComparisonID::kGreater) + .makeUncheckedComparatorForTypes(type, type)); std::string string_literal; std::string max = ""; int val; @@ -291,15 +305,17 @@ class AggregationHandleMaxTest : public ::testing::Test { iterateHandle( aggregation_handle_max_state_.get(), - type.makeValue(string_literal.c_str(), - string_literal.length() + 1).ensureNotReference()); - if (fast_comparator_->compareDataPtrs(string_literal.c_str(), max.c_str())) { + type.makeValue(string_literal.c_str(), string_literal.length() + 1) + .ensureNotReference()); + if (fast_comparator_->compareDataPtrs(string_literal.c_str(), + max.c_str())) { max = string_literal; } } } iterateHandle(aggregation_handle_max_state_.get(), type.makeNullValue()); - CheckMaxString(max, *aggregation_handle_max_, *aggregation_handle_max_state_); + CheckMaxString( + max, *aggregation_handle_max_, *aggregation_handle_max_state_); // Test mergeStates(). std::unique_ptr<AggregationState> merge_state( @@ -317,24 +333,28 @@ class AggregationHandleMaxTest : public ::testing::Test { iterateHandle( merge_state.get(), - type.makeValue(string_literal.c_str(), - string_literal.length() + 1).ensureNotReference()); - if (fast_comparator_->compareDataPtrs(string_literal.c_str(), max.c_str())) { + type.makeValue(string_literal.c_str(), string_literal.length() + 1) + .ensureNotReference()); + if (fast_comparator_->compareDataPtrs(string_literal.c_str(), + max.c_str())) { max = string_literal; } } } aggregation_handle_max_->mergeStates(*merge_state, aggregation_handle_max_state_.get()); - CheckMaxString(max, *aggregation_handle_max_, *aggregation_handle_max_state_); + CheckMaxString( + max, *aggregation_handle_max_, *aggregation_handle_max_state_); } template <typename ColumnVectorType> - ColumnVector *createColumnVectorString(const Type &type, std::string *max) { - ColumnVectorType *column = new ColumnVectorType(type, kIterations * kNumSamples + 3); + ColumnVector* createColumnVectorString(const Type &type, std::string *max) { + ColumnVectorType *column = + new ColumnVectorType(type, kIterations * kNumSamples + 3); std::unique_ptr<UncheckedComparator> fast_comparator_; - fast_comparator_.reset(ComparisonFactory::GetComparison(ComparisonID::kGreater) - .makeUncheckedComparatorForTypes(type, type)); + fast_comparator_.reset( + ComparisonFactory::GetComparison(ComparisonID::kGreater) + .makeUncheckedComparatorForTypes(type, type)); std::string string_literal; *max = ""; int val; @@ -346,14 +366,16 @@ class AggregationHandleMaxTest : public ::testing::Test { oss << "max" << val; string_literal = oss.str(); - column->appendTypedValue(type.makeValue(string_literal.c_str(), string_literal.length() + 1) - .ensureNotReference()); - if (fast_comparator_->compareDataPtrs(string_literal.c_str(), max->c_str())) { + column->appendTypedValue( + type.makeValue(string_literal.c_str(), string_literal.length() + 1) + .ensureNotReference()); + if (fast_comparator_->compareDataPtrs(string_literal.c_str(), + max->c_str())) { *max = string_literal; } } // One NULL in the middle. - if (i == kIterations/2) { + if (i == kIterations / 2) { column->appendTypedValue(type.makeNullValue()); } } @@ -366,25 +388,26 @@ class AggregationHandleMaxTest : public ::testing::Test { void checkAggregationMaxStringColumnVector() { const StringType &type = StringType::Instance(10, true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_max_->finalize(*aggregation_handle_max_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_max_->finalize(*aggregation_handle_max_state_) + .isNull()); std::string max; std::vector<std::unique_ptr<ColumnVector>> column_vectors; - column_vectors.emplace_back(createColumnVectorString<ColumnVectorType>(type, &max)); + column_vectors.emplace_back( + createColumnVectorString<ColumnVectorType>(type, &max)); std::unique_ptr<AggregationState> cv_state( aggregation_handle_max_->accumulateColumnVectors(column_vectors)); // Test the state generated directly by accumulateColumnVectors(), and also // test after merging back. - CheckMaxString(max, - *aggregation_handle_max_, - *cv_state); - - aggregation_handle_max_->mergeStates(*cv_state, aggregation_handle_max_state_.get()); - CheckMaxString(max, - *aggregation_handle_max_, - *aggregation_handle_max_state_); + CheckMaxString(max, *aggregation_handle_max_, *cv_state); + + aggregation_handle_max_->mergeStates(*cv_state, + aggregation_handle_max_state_.get()); + CheckMaxString( + max, *aggregation_handle_max_, *aggregation_handle_max_state_); } #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -392,26 +415,27 @@ class AggregationHandleMaxTest : public ::testing::Test { void checkAggregationMaxStringValueAccessor() { const StringType &type = StringType::Instance(10, true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_max_->finalize(*aggregation_handle_max_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_max_->finalize(*aggregation_handle_max_state_) + .isNull()); std::string max; - std::unique_ptr<ColumnVectorsValueAccessor> accessor(new ColumnVectorsValueAccessor()); + std::unique_ptr<ColumnVectorsValueAccessor> accessor( + new ColumnVectorsValueAccessor()); accessor->addColumn(createColumnVectorString<ColumnVectorType>(type, &max)); std::unique_ptr<AggregationState> va_state( - aggregation_handle_max_->accumulateValueAccessor(accessor.get(), - std::vector<attribute_id>(1, 0))); + aggregation_handle_max_->accumulateValueAccessor( + accessor.get(), std::vector<attribute_id>(1, 0))); // Test the state generated directly by accumulateValueAccessor(), and also // test after merging back. - CheckMaxString(max, - *aggregation_handle_max_, - *va_state); - - aggregation_handle_max_->mergeStates(*va_state, aggregation_handle_max_state_.get()); - CheckMaxString(max, - *aggregation_handle_max_, - *aggregation_handle_max_state_); + CheckMaxString(max, *aggregation_handle_max_, *va_state); + + aggregation_handle_max_->mergeStates(*va_state, + aggregation_handle_max_state_.get()); + CheckMaxString( + max, *aggregation_handle_max_, *aggregation_handle_max_state_); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -422,9 +446,7 @@ class AggregationHandleMaxTest : public ::testing::Test { template <> void AggregationHandleMaxTest::CheckMaxValue<float>( - float val, - const AggregationHandle &handle, - const AggregationState &state) { + float val, const AggregationHandle &handle, const AggregationState &state) { EXPECT_FLOAT_EQ(val, handle.finalize(state).getLiteral<float>()); } @@ -437,17 +459,20 @@ void AggregationHandleMaxTest::CheckMaxValue<double>( } template <> -void AggregationHandleMaxTest::SetDataType<DatetimeLit>(int value, DatetimeLit *data) { +void AggregationHandleMaxTest::SetDataType<DatetimeLit>(int value, + DatetimeLit *data) { data->ticks = value; } template <> -void AggregationHandleMaxTest::SetDataType<DatetimeIntervalLit>(int value, DatetimeIntervalLit *data) { +void AggregationHandleMaxTest::SetDataType<DatetimeIntervalLit>( + int value, DatetimeIntervalLit *data) { data->interval_ticks = value; } template <> -void AggregationHandleMaxTest::SetDataType<YearMonthIntervalLit>(int value, YearMonthIntervalLit *data) { +void AggregationHandleMaxTest::SetDataType<YearMonthIntervalLit>( + int value, YearMonthIntervalLit *data) { data->months = value; } @@ -579,50 +604,67 @@ TEST_F(AggregationHandleMaxDeathTest, WrongTypeTest) { float float_val = 0; // Passes. - iterateHandle(aggregation_handle_max_state_.get(), int_non_null_type.makeValue(&int_val)); + iterateHandle(aggregation_handle_max_state_.get(), + int_non_null_type.makeValue(&int_val)); - EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), long_type.makeValue(&long_val)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), double_type.makeValue(&double_val)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), float_type.makeValue(&float_val)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), char_type.makeValue("asdf", 5)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), varchar_type.makeValue("asdf", 5)), ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), + long_type.makeValue(&long_val)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), + double_type.makeValue(&double_val)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), + float_type.makeValue(&float_val)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), + char_type.makeValue("asdf", 5)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_max_state_.get(), + varchar_type.makeValue("asdf", 5)), + ""); // Test mergeStates() with incorrectly typed handles. std::unique_ptr<AggregationHandle> aggregation_handle_max_long( - AggregateFunctionFactory::Get(AggregationID::kMax).createHandle( - std::vector<const Type*>(1, &long_type))); + AggregateFunctionFactory::Get(AggregationID::kMax) + .createHandle(std::vector<const Type *>(1, &long_type))); std::unique_ptr<AggregationState> aggregation_state_max_merge_long( aggregation_handle_max_long->createInitialState()); - static_cast<const AggregationHandleMax&>(*aggregation_handle_max_long).iterateUnaryInl( - static_cast<AggregationStateMax*>(aggregation_state_max_merge_long.get()), - long_type.makeValue(&long_val)); - EXPECT_DEATH(aggregation_handle_max_->mergeStates(*aggregation_state_max_merge_long, - aggregation_handle_max_state_.get()), - ""); + static_cast<const AggregationHandleMax &>(*aggregation_handle_max_long) + .iterateUnaryInl(static_cast<AggregationStateMax *>( + aggregation_state_max_merge_long.get()), + long_type.makeValue(&long_val)); + EXPECT_DEATH( + aggregation_handle_max_->mergeStates(*aggregation_state_max_merge_long, + aggregation_handle_max_state_.get()), + ""); std::unique_ptr<AggregationHandle> aggregation_handle_max_double( - AggregateFunctionFactory::Get(AggregationID::kMax).createHandle( - std::vector<const Type*>(1, &double_type))); + AggregateFunctionFactory::Get(AggregationID::kMax) + .createHandle(std::vector<const Type *>(1, &double_type))); std::unique_ptr<AggregationState> aggregation_state_max_merge_double( aggregation_handle_max_double->createInitialState()); - static_cast<const AggregationHandleMax&>(*aggregation_handle_max_double).iterateUnaryInl( - static_cast<AggregationStateMax*>(aggregation_state_max_merge_double.get()), - double_type.makeValue(&double_val)); - EXPECT_DEATH(aggregation_handle_max_->mergeStates(*aggregation_state_max_merge_double, - aggregation_handle_max_state_.get()), - ""); + static_cast<const AggregationHandleMax &>(*aggregation_handle_max_double) + .iterateUnaryInl(static_cast<AggregationStateMax *>( + aggregation_state_max_merge_double.get()), + double_type.makeValue(&double_val)); + EXPECT_DEATH( + aggregation_handle_max_->mergeStates(*aggregation_state_max_merge_double, + aggregation_handle_max_state_.get()), + ""); std::unique_ptr<AggregationHandle> aggregation_handle_max_float( - AggregateFunctionFactory::Get(AggregationID::kMax).createHandle( - std::vector<const Type*>(1, &float_type))); + AggregateFunctionFactory::Get(AggregationID::kMax) + .createHandle(std::vector<const Type *>(1, &float_type))); std::unique_ptr<AggregationState> aggregation_state_max_merge_float( aggregation_handle_max_float->createInitialState()); - static_cast<const AggregationHandleMax&>(*aggregation_handle_max_float).iterateUnaryInl( - static_cast<AggregationStateMax*>(aggregation_state_max_merge_float.get()), - float_type.makeValue(&float_val)); - EXPECT_DEATH(aggregation_handle_max_->mergeStates(*aggregation_state_max_merge_float, - aggregation_handle_max_state_.get()), - ""); + static_cast<const AggregationHandleMax &>(*aggregation_handle_max_float) + .iterateUnaryInl(static_cast<AggregationStateMax *>( + aggregation_state_max_merge_float.get()), + float_type.makeValue(&float_val)); + EXPECT_DEATH( + aggregation_handle_max_->mergeStates(*aggregation_state_max_merge_float, + aggregation_handle_max_state_.get()), + ""); } #endif @@ -647,25 +689,28 @@ TEST_F(AggregationHandleMaxTest, GroupByTableMergeTest) { initializeHandle(int_non_null_type); storage_manager_.reset(new StorageManager("./test_max_data")); std::unique_ptr<AggregationStateHashTableBase> source_hash_table( - aggregation_handle_max_->createGroupByHashTable( - HashTableImplType::kSimpleScalarSeparateChaining, + AggregationStateFastHashTableFactory::CreateResizable( + HashTableImplType::kSeparateChaining, std::vector<const Type *>(1, &int_non_null_type), 10, + {aggregation_handle_max_.get()->getPayloadSize()}, + {aggregation_handle_max_.get()}, storage_manager_.get())); std::unique_ptr<AggregationStateHashTableBase> destination_hash_table( - aggregation_handle_max_->createGroupByHashTable( - HashTableImplType::kSimpleScalarSeparateChaining, + AggregationStateFastHashTableFactory::CreateResizable( + HashTableImplType::kSeparateChaining, std::vector<const Type *>(1, &int_non_null_type), 10, + {aggregation_handle_max_.get()->getPayloadSize()}, + {aggregation_handle_max_.get()}, storage_manager_.get())); - AggregationStateHashTable<AggregationStateMax> *destination_hash_table_derived = - static_cast<AggregationStateHashTable<AggregationStateMax> *>( + AggregationStateFastHashTable *destination_hash_table_derived = + static_cast<AggregationStateFastHashTable *>( destination_hash_table.get()); - AggregationStateHashTable<AggregationStateMax> *source_hash_table_derived = - static_cast<AggregationStateHashTable<AggregationStateMax> *>( - source_hash_table.get()); + AggregationStateFastHashTable *source_hash_table_derived = + static_cast<AggregationStateFastHashTable *>(source_hash_table.get()); AggregationHandleMax *aggregation_handle_max_derived = static_cast<AggregationHandleMax *>(aggregation_handle_max_.get()); @@ -730,35 +775,52 @@ TEST_F(AggregationHandleMaxTest, GroupByTableMergeTest) { EXPECT_EQ(exclusive_key_source_max_val.getLiteral<int>(), actual_val); // Add the key-state pairs to the hash tables. - source_hash_table_derived->putCompositeKey(common_key, - *common_key_source_state); - destination_hash_table_derived->putCompositeKey( - common_key, *common_key_destination_state); - source_hash_table_derived->putCompositeKey(exclusive_source_key, - *exclusive_key_source_state); - destination_hash_table_derived->putCompositeKey( - exclusive_destination_key, *exclusive_key_destination_state); + unsigned char buffer[100]; + buffer[0] = '\0'; + memcpy(buffer + 1, + common_key_source_state.get()->getPayloadAddress(), + aggregation_handle_max_.get()->getPayloadSize()); + source_hash_table_derived->putCompositeKey(common_key, buffer); + + memcpy(buffer + 1, + common_key_destination_state.get()->getPayloadAddress(), + aggregation_handle_max_.get()->getPayloadSize()); + destination_hash_table_derived->putCompositeKey(common_key, buffer); + + memcpy(buffer + 1, + exclusive_key_source_state.get()->getPayloadAddress(), + aggregation_handle_max_.get()->getPayloadSize()); + source_hash_table_derived->putCompositeKey(exclusive_source_key, buffer); + + memcpy(buffer + 1, + exclusive_key_destination_state.get()->getPayloadAddress(), + aggregation_handle_max_.get()->getPayloadSize()); + destination_hash_table_derived->putCompositeKey(exclusive_destination_key, + buffer); EXPECT_EQ(2u, destination_hash_table_derived->numEntries()); EXPECT_EQ(2u, source_hash_table_derived->numEntries()); - aggregation_handle_max_->mergeGroupByHashTables(*source_hash_table, - destination_hash_table.get()); + AggregationOperationState::mergeGroupByHashTables( + source_hash_table.get(), destination_hash_table.get()); EXPECT_EQ(3u, destination_hash_table_derived->numEntries()); CheckMaxValue<int>( common_key_destination_max_val.getLiteral<int>(), - *aggregation_handle_max_derived, - *(destination_hash_table_derived->getSingleCompositeKey(common_key))); + aggregation_handle_max_derived->finalizeHashTableEntryFast( + destination_hash_table_derived->getSingleCompositeKey(common_key) + + 1)); CheckMaxValue<int>(exclusive_key_destination_max_val.getLiteral<int>(), - *aggregation_handle_max_derived, - *(destination_hash_table_derived->getSingleCompositeKey( - exclusive_destination_key))); + aggregation_handle_max_derived->finalizeHashTableEntryFast( + destination_hash_table_derived->getSingleCompositeKey( + exclusive_destination_key) + + 1)); CheckMaxValue<int>(exclusive_key_source_max_val.getLiteral<int>(), - *aggregation_handle_max_derived, - *(source_hash_table_derived->getSingleCompositeKey( - exclusive_source_key))); + aggregation_handle_max_derived->finalizeHashTableEntryFast( + source_hash_table_derived->getSingleCompositeKey( + exclusive_source_key) + + 1)); } } // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c123bd49/expressions/aggregation/tests/AggregationHandleMin_unittest.cpp ---------------------------------------------------------------------- diff --git a/expressions/aggregation/tests/AggregationHandleMin_unittest.cpp b/expressions/aggregation/tests/AggregationHandleMin_unittest.cpp index 85c3bf3..6e6d188 100644 --- a/expressions/aggregation/tests/AggregationHandleMin_unittest.cpp +++ b/expressions/aggregation/tests/AggregationHandleMin_unittest.cpp @@ -31,6 +31,8 @@ #include "expressions/aggregation/AggregationHandle.hpp" #include "expressions/aggregation/AggregationHandleMin.hpp" #include "expressions/aggregation/AggregationID.hpp" +#include "storage/AggregationOperationState.hpp" +#include "storage/FastHashTableFactory.hpp" #include "storage/StorageManager.hpp" #include "types/CharType.hpp" #include "types/DatetimeIntervalType.hpp" @@ -69,54 +71,59 @@ class AggregationHandleMinTest : public ::testing::Test { // Helper method that calls AggregationHandleMin::iterateUnaryInl() to // aggregate 'value' into '*state'. void iterateHandle(AggregationState *state, const TypedValue &value) { - static_cast<const AggregationHandleMin&>(*aggregation_handle_min_).iterateUnaryInl( - static_cast<AggregationStateMin*>(state), - value); + static_cast<const AggregationHandleMin &>(*aggregation_handle_min_) + .iterateUnaryInl(static_cast<AggregationStateMin *>(state), value); } void initializeHandle(const Type &type) { aggregation_handle_min_.reset( - AggregateFunctionFactory::Get(AggregationID::kMin).createHandle( - std::vector<const Type*>(1, &type))); + AggregateFunctionFactory::Get(AggregationID::kMin) + .createHandle(std::vector<const Type *>(1, &type))); aggregation_handle_min_state_.reset( aggregation_handle_min_->createInitialState()); } static bool ApplyToTypesTest(TypeID typeID) { - const Type &type = (typeID == kChar || typeID == kVarChar) ? - TypeFactory::GetType(typeID, static_cast<std::size_t>(10)) : - TypeFactory::GetType(typeID); + const Type &type = + (typeID == kChar || typeID == kVarChar) + ? TypeFactory::GetType(typeID, static_cast<std::size_t>(10)) + : TypeFactory::GetType(typeID); - return AggregateFunctionFactory::Get(AggregationID::kMin).canApplyToTypes( - std::vector<const Type*>(1, &type)); + return AggregateFunctionFactory::Get(AggregationID::kMin) + .canApplyToTypes(std::vector<const Type *>(1, &type)); } static bool ResultTypeForArgumentTypeTest(TypeID input_type_id, TypeID output_type_id) { - const Type *result_type - = AggregateFunctionFactory::Get(AggregationID::kMin).resultTypeForArgumentTypes( - std::vector<const Type*>(1, &TypeFactory::GetType(input_type_id))); + const Type *result_type = + AggregateFunctionFactory::Get(AggregationID::kMin) + .resultTypeForArgumentTypes(std::vector<const Type *>( + 1, &TypeFactory::GetType(input_type_id))); return (result_type->getTypeID() == output_type_id); } template <typename CppType> - static void CheckMinValue( - CppType expected, - const AggregationHandle &handle, - const AggregationState &state) { + static void CheckMinValue(CppType expected, + const AggregationHandle &handle, + const AggregationState &state) { EXPECT_EQ(expected, handle.finalize(state).getLiteral<CppType>()); } - static void CheckMinString( - const std::string &expected, - const AggregationHandle &handle, - const AggregationState &state) { + template <typename CppType> + static void CheckMinValue(CppType expected, const TypedValue &value) { + EXPECT_EQ(expected, value.getLiteral<CppType>()); + } + + static void CheckMinString(const std::string &expected, + const AggregationHandle &handle, + const AggregationState &state) { TypedValue value = handle.finalize(state); ASSERT_EQ(expected.length(), value.getAsciiStringLength()); - EXPECT_EQ(0, std::strncmp(expected.c_str(), - static_cast <const char *>(value.getDataPtr()), - value.getAsciiStringLength())); + EXPECT_EQ(0, + std::strncmp(expected.c_str(), + static_cast<const char *>(value.getDataPtr()), + value.getAsciiStringLength())); } // Static templated method to initialize data types. @@ -129,7 +136,9 @@ class AggregationHandleMinTest : public ::testing::Test { void checkAggregationMinGeneric() { const GenericType &type = GenericType::Instance(true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_min_->finalize(*aggregation_handle_min_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_min_->finalize(*aggregation_handle_min_state_) + .isNull()); typename GenericType::cpptype val; typename GenericType::cpptype min; @@ -141,16 +150,18 @@ class AggregationHandleMinTest : public ::testing::Test { if (type.getTypeID() == kInt || type.getTypeID() == kLong) { SetDataType(i * kNumSamples + j - 10, &val); } else { - SetDataType(static_cast<float>(i * kNumSamples + j - 10)/10, &val); + SetDataType(static_cast<float>(i * kNumSamples + j - 10) / 10, &val); } - iterateHandle(aggregation_handle_min_state_.get(), type.makeValue(&val)); + iterateHandle(aggregation_handle_min_state_.get(), + type.makeValue(&val)); if (min > val) { min = val; } } } iterateHandle(aggregation_handle_min_state_.get(), type.makeNullValue()); - CheckMinValue<typename GenericType::cpptype>(min, *aggregation_handle_min_, *aggregation_handle_min_state_); + CheckMinValue<typename GenericType::cpptype>( + min, *aggregation_handle_min_, *aggregation_handle_min_state_); // Test mergeStates(). std::unique_ptr<AggregationState> merge_state( @@ -164,7 +175,7 @@ class AggregationHandleMinTest : public ::testing::Test { if (type.getTypeID() == kInt || type.getTypeID() == kLong) { SetDataType(i * kNumSamples + j - 20, &val); } else { - SetDataType(static_cast<float>(i * kNumSamples + j - 20)/10, &val); + SetDataType(static_cast<float>(i * kNumSamples + j - 20) / 10, &val); } iterateHandle(merge_state.get(), type.makeValue(&val)); if (min > val) { @@ -175,14 +186,14 @@ class AggregationHandleMinTest : public ::testing::Test { aggregation_handle_min_->mergeStates(*merge_state, aggregation_handle_min_state_.get()); CheckMinValue<typename GenericType::cpptype>( - min, - *aggregation_handle_min_, - *aggregation_handle_min_state_); + min, *aggregation_handle_min_, *aggregation_handle_min_state_); } template <typename GenericType> - ColumnVector *createColumnVectorGeneric(const Type &type, typename GenericType::cpptype *min) { - NativeColumnVector *column = new NativeColumnVector(type, kIterations * kNumSamples + 3); + ColumnVector* createColumnVectorGeneric(const Type &type, + typename GenericType::cpptype *min) { + NativeColumnVector *column = + new NativeColumnVector(type, kIterations * kNumSamples + 3); typename GenericType::cpptype val; SetDataType(1000, min); @@ -193,7 +204,7 @@ class AggregationHandleMinTest : public ::testing::Test { if (type.getTypeID() == kInt || type.getTypeID() == kLong) { SetDataType(i * kNumSamples + j - 10, &val); } else { - SetDataType(static_cast<float>(i * kNumSamples + j - 10)/10, &val); + SetDataType(static_cast<float>(i * kNumSamples + j - 10) / 10, &val); } column->appendTypedValue(type.makeValue(&val)); if (*min > val) { @@ -201,7 +212,7 @@ class AggregationHandleMinTest : public ::testing::Test { } } // One NULL in the middle. - if (i == kIterations/2) { + if (i == kIterations / 2) { column->appendTypedValue(type.makeNullValue()); } } @@ -214,11 +225,14 @@ class AggregationHandleMinTest : public ::testing::Test { void checkAggregationMinGenericColumnVector() { const GenericType &type = GenericType::Instance(true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_min_->finalize(*aggregation_handle_min_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_min_->finalize(*aggregation_handle_min_state_) + .isNull()); typename GenericType::cpptype min; std::vector<std::unique_ptr<ColumnVector>> column_vectors; - column_vectors.emplace_back(createColumnVectorGeneric<GenericType>(type, &min)); + column_vectors.emplace_back( + createColumnVectorGeneric<GenericType>(type, &min)); std::unique_ptr<AggregationState> cv_state( aggregation_handle_min_->accumulateColumnVectors(column_vectors)); @@ -226,15 +240,12 @@ class AggregationHandleMinTest : public ::testing::Test { // Test the state generated directly by accumulateColumnVectors(), and also // test after merging back. CheckMinValue<typename GenericType::cpptype>( - min, - *aggregation_handle_min_, - *cv_state); + min, *aggregation_handle_min_, *cv_state); - aggregation_handle_min_->mergeStates(*cv_state, aggregation_handle_min_state_.get()); + aggregation_handle_min_->mergeStates(*cv_state, + aggregation_handle_min_state_.get()); CheckMinValue<typename GenericType::cpptype>( - min, - *aggregation_handle_min_, - *aggregation_handle_min_state_); + min, *aggregation_handle_min_, *aggregation_handle_min_state_); } #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -242,29 +253,29 @@ class AggregationHandleMinTest : public ::testing::Test { void checkAggregationMinGenericValueAccessor() { const GenericType &type = GenericType::Instance(true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_min_->finalize(*aggregation_handle_min_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_min_->finalize(*aggregation_handle_min_state_) + .isNull()); - std::unique_ptr<ColumnVectorsValueAccessor> accessor(new ColumnVectorsValueAccessor()); + std::unique_ptr<ColumnVectorsValueAccessor> accessor( + new ColumnVectorsValueAccessor()); typename GenericType::cpptype min; accessor->addColumn(createColumnVectorGeneric<GenericType>(type, &min)); std::unique_ptr<AggregationState> va_state( - aggregation_handle_min_->accumulateValueAccessor(accessor.get(), - std::vector<attribute_id>(1, 0))); + aggregation_handle_min_->accumulateValueAccessor( + accessor.get(), std::vector<attribute_id>(1, 0))); // Test the state generated directly by accumulateValueAccessor(), and also // test after merging back. CheckMinValue<typename GenericType::cpptype>( - min, - *aggregation_handle_min_, - *va_state); + min, *aggregation_handle_min_, *va_state); - aggregation_handle_min_->mergeStates(*va_state, aggregation_handle_min_state_.get()); + aggregation_handle_min_->mergeStates(*va_state, + aggregation_handle_min_state_.get()); CheckMinValue<typename GenericType::cpptype>( - min, - *aggregation_handle_min_, - *aggregation_handle_min_state_); + min, *aggregation_handle_min_, *aggregation_handle_min_state_); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -272,11 +283,13 @@ class AggregationHandleMinTest : public ::testing::Test { void checkAggregationMinString() { const StringType &type = StringType::Instance(10, true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_min_->finalize(*aggregation_handle_min_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_min_->finalize(*aggregation_handle_min_state_) + .isNull()); std::unique_ptr<UncheckedComparator> fast_comparator_; fast_comparator_.reset(ComparisonFactory::GetComparison(ComparisonID::kLess) - .makeUncheckedComparatorForTypes(type, type)); + .makeUncheckedComparatorForTypes(type, type)); std::string string_literal; std::string min = "z"; int val; @@ -288,15 +301,19 @@ class AggregationHandleMinTest : public ::testing::Test { oss << "test" << val; string_literal = oss.str(); - iterateHandle(aggregation_handle_min_state_.get(), type.makeValue(string_literal.c_str(), - string_literal.length() + 1).ensureNotReference()); - if (fast_comparator_->compareDataPtrs(string_literal.c_str(), min.c_str())) { + iterateHandle( + aggregation_handle_min_state_.get(), + type.makeValue(string_literal.c_str(), string_literal.length() + 1) + .ensureNotReference()); + if (fast_comparator_->compareDataPtrs(string_literal.c_str(), + min.c_str())) { min = string_literal; } } } iterateHandle(aggregation_handle_min_state_.get(), type.makeNullValue()); - CheckMinString(min, *aggregation_handle_min_, *aggregation_handle_min_state_); + CheckMinString( + min, *aggregation_handle_min_, *aggregation_handle_min_state_); // Test mergeStates(). std::unique_ptr<AggregationState> merge_state( @@ -314,24 +331,27 @@ class AggregationHandleMinTest : public ::testing::Test { iterateHandle( merge_state.get(), - type.makeValue(string_literal.c_str(), - string_literal.length() + 1).ensureNotReference()); - if (fast_comparator_->compareDataPtrs(string_literal.c_str(), min.c_str())) { + type.makeValue(string_literal.c_str(), string_literal.length() + 1) + .ensureNotReference()); + if (fast_comparator_->compareDataPtrs(string_literal.c_str(), + min.c_str())) { min = string_literal; } } } aggregation_handle_min_->mergeStates(*merge_state, aggregation_handle_min_state_.get()); - CheckMinString(min, *aggregation_handle_min_, *aggregation_handle_min_state_); + CheckMinString( + min, *aggregation_handle_min_, *aggregation_handle_min_state_); } template <typename ColumnVectorType> - ColumnVector *createColumnVectorString(const Type &type, std::string *min) { - ColumnVectorType *column = new ColumnVectorType(type, kIterations * kNumSamples + 3); + ColumnVector* createColumnVectorString(const Type &type, std::string *min) { + ColumnVectorType *column = + new ColumnVectorType(type, kIterations * kNumSamples + 3); std::unique_ptr<UncheckedComparator> fast_comparator_; fast_comparator_.reset(ComparisonFactory::GetComparison(ComparisonID::kLess) - .makeUncheckedComparatorForTypes(type, type)); + .makeUncheckedComparatorForTypes(type, type)); std::string string_literal; *min = "z"; int val; @@ -343,14 +363,16 @@ class AggregationHandleMinTest : public ::testing::Test { oss << "test" << val; string_literal = oss.str(); - column->appendTypedValue(type.makeValue(string_literal.c_str(), string_literal.length() + 1) - .ensureNotReference()); - if (fast_comparator_->compareDataPtrs(string_literal.c_str(), min->c_str())) { + column->appendTypedValue( + type.makeValue(string_literal.c_str(), string_literal.length() + 1) + .ensureNotReference()); + if (fast_comparator_->compareDataPtrs(string_literal.c_str(), + min->c_str())) { *min = string_literal; } } // One NULL in the middle. - if (i == kIterations/2) { + if (i == kIterations / 2) { column->appendTypedValue(type.makeNullValue()); } } @@ -363,25 +385,26 @@ class AggregationHandleMinTest : public ::testing::Test { void checkAggregationMinStringColumnVector() { const StringType &type = StringType::Instance(10, true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_min_->finalize(*aggregation_handle_min_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_min_->finalize(*aggregation_handle_min_state_) + .isNull()); std::string min; std::vector<std::unique_ptr<ColumnVector>> column_vectors; - column_vectors.emplace_back(createColumnVectorString<ColumnVectorType>(type, &min)); + column_vectors.emplace_back( + createColumnVectorString<ColumnVectorType>(type, &min)); std::unique_ptr<AggregationState> cv_state( aggregation_handle_min_->accumulateColumnVectors(column_vectors)); // Test the state generated directly by accumulateColumnVectors(), and also // test after merging back. - CheckMinString(min, - *aggregation_handle_min_, - *cv_state); - - aggregation_handle_min_->mergeStates(*cv_state, aggregation_handle_min_state_.get()); - CheckMinString(min, - *aggregation_handle_min_, - *aggregation_handle_min_state_); + CheckMinString(min, *aggregation_handle_min_, *cv_state); + + aggregation_handle_min_->mergeStates(*cv_state, + aggregation_handle_min_state_.get()); + CheckMinString( + min, *aggregation_handle_min_, *aggregation_handle_min_state_); } #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -389,26 +412,27 @@ class AggregationHandleMinTest : public ::testing::Test { void checkAggregationMinStringValueAccessor() { const StringType &type = StringType::Instance(10, true); initializeHandle(type); - EXPECT_TRUE(aggregation_handle_min_->finalize(*aggregation_handle_min_state_).isNull()); + EXPECT_TRUE( + aggregation_handle_min_->finalize(*aggregation_handle_min_state_) + .isNull()); std::string min; - std::unique_ptr<ColumnVectorsValueAccessor> accessor(new ColumnVectorsValueAccessor()); + std::unique_ptr<ColumnVectorsValueAccessor> accessor( + new ColumnVectorsValueAccessor()); accessor->addColumn(createColumnVectorString<ColumnVectorType>(type, &min)); std::unique_ptr<AggregationState> va_state( - aggregation_handle_min_->accumulateValueAccessor(accessor.get(), - std::vector<attribute_id>(1, 0))); + aggregation_handle_min_->accumulateValueAccessor( + accessor.get(), std::vector<attribute_id>(1, 0))); // Test the state generated directly by accumulateValueAccessor(), and also // test after merging back. - CheckMinString(min, - *aggregation_handle_min_, - *va_state); - - aggregation_handle_min_->mergeStates(*va_state, aggregation_handle_min_state_.get()); - CheckMinString(min, - *aggregation_handle_min_, - *aggregation_handle_min_state_); + CheckMinString(min, *aggregation_handle_min_, *va_state); + + aggregation_handle_min_->mergeStates(*va_state, + aggregation_handle_min_state_.get()); + CheckMinString( + min, *aggregation_handle_min_, *aggregation_handle_min_state_); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION @@ -419,9 +443,7 @@ class AggregationHandleMinTest : public ::testing::Test { template <> void AggregationHandleMinTest::CheckMinValue<float>( - float val, - const AggregationHandle &handle, - const AggregationState &state) { + float val, const AggregationHandle &handle, const AggregationState &state) { EXPECT_FLOAT_EQ(val, handle.finalize(state).getLiteral<float>()); } @@ -434,17 +456,20 @@ void AggregationHandleMinTest::CheckMinValue<double>( } template <> -void AggregationHandleMinTest::SetDataType<DatetimeLit>(int value, DatetimeLit *data) { +void AggregationHandleMinTest::SetDataType<DatetimeLit>(int value, + DatetimeLit *data) { data->ticks = value; } template <> -void AggregationHandleMinTest::SetDataType<DatetimeIntervalLit>(int value, DatetimeIntervalLit *data) { +void AggregationHandleMinTest::SetDataType<DatetimeIntervalLit>( + int value, DatetimeIntervalLit *data) { data->interval_ticks = value; } template <> -void AggregationHandleMinTest::SetDataType<YearMonthIntervalLit>(int value, YearMonthIntervalLit *data) { +void AggregationHandleMinTest::SetDataType<YearMonthIntervalLit>( + int value, YearMonthIntervalLit *data) { data->months = value; } @@ -575,50 +600,67 @@ TEST_F(AggregationHandleMinDeathTest, WrongTypeTest) { double double_val = 0; float float_val = 0; - iterateHandle(aggregation_handle_min_state_.get(), int_non_null_type.makeValue(&int_val)); + iterateHandle(aggregation_handle_min_state_.get(), + int_non_null_type.makeValue(&int_val)); - EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), long_type.makeValue(&long_val)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), double_type.makeValue(&double_val)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), float_type.makeValue(&float_val)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), char_type.makeValue("asdf", 5)), ""); - EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), varchar_type.makeValue("asdf", 5)), ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), + long_type.makeValue(&long_val)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), + double_type.makeValue(&double_val)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), + float_type.makeValue(&float_val)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), + char_type.makeValue("asdf", 5)), + ""); + EXPECT_DEATH(iterateHandle(aggregation_handle_min_state_.get(), + varchar_type.makeValue("asdf", 5)), + ""); // Test mergeStates() with incorrectly typed handles. std::unique_ptr<AggregationHandle> aggregation_handle_min_long( - AggregateFunctionFactory::Get(AggregationID::kMin).createHandle( - std::vector<const Type*>(1, &long_type))); + AggregateFunctionFactory::Get(AggregationID::kMin) + .createHandle(std::vector<const Type *>(1, &long_type))); std::unique_ptr<AggregationState> aggregation_state_min_merge_long( aggregation_handle_min_long->createInitialState()); - static_cast<const AggregationHandleMin&>(*aggregation_handle_min_long).iterateUnaryInl( - static_cast<AggregationStateMin*>(aggregation_state_min_merge_long.get()), - long_type.makeValue(&long_val)); - EXPECT_DEATH(aggregation_handle_min_->mergeStates(*aggregation_state_min_merge_long, - aggregation_handle_min_state_.get()), - ""); + static_cast<const AggregationHandleMin &>(*aggregation_handle_min_long) + .iterateUnaryInl(static_cast<AggregationStateMin *>( + aggregation_state_min_merge_long.get()), + long_type.makeValue(&long_val)); + EXPECT_DEATH( + aggregation_handle_min_->mergeStates(*aggregation_state_min_merge_long, + aggregation_handle_min_state_.get()), + ""); std::unique_ptr<AggregationHandle> aggregation_handle_min_double( - AggregateFunctionFactory::Get(AggregationID::kMin).createHandle( - std::vector<const Type*>(1, &double_type))); + AggregateFunctionFactory::Get(AggregationID::kMin) + .createHandle(std::vector<const Type *>(1, &double_type))); std::unique_ptr<AggregationState> aggregation_state_min_merge_double( aggregation_handle_min_double->createInitialState()); - static_cast<const AggregationHandleMin&>(*aggregation_handle_min_double).iterateUnaryInl( - static_cast<AggregationStateMin*>(aggregation_state_min_merge_double.get()), - double_type.makeValue(&double_val)); - EXPECT_DEATH(aggregation_handle_min_->mergeStates(*aggregation_state_min_merge_double, - aggregation_handle_min_state_.get()), - ""); + static_cast<const AggregationHandleMin &>(*aggregation_handle_min_double) + .iterateUnaryInl(static_cast<AggregationStateMin *>( + aggregation_state_min_merge_double.get()), + double_type.makeValue(&double_val)); + EXPECT_DEATH( + aggregation_handle_min_->mergeStates(*aggregation_state_min_merge_double, + aggregation_handle_min_state_.get()), + ""); std::unique_ptr<AggregationHandle> aggregation_handle_min_float( - AggregateFunctionFactory::Get(AggregationID::kMin).createHandle( - std::vector<const Type*>(1, &float_type))); + AggregateFunctionFactory::Get(AggregationID::kMin) + .createHandle(std::vector<const Type *>(1, &float_type))); std::unique_ptr<AggregationState> aggregation_state_min_merge_float( aggregation_handle_min_float->createInitialState()); - static_cast<const AggregationHandleMin&>(*aggregation_handle_min_float).iterateUnaryInl( - static_cast<AggregationStateMin*>(aggregation_state_min_merge_float.get()), - float_type.makeValue(&float_val)); - EXPECT_DEATH(aggregation_handle_min_->mergeStates(*aggregation_state_min_merge_float, - aggregation_handle_min_state_.get()), - ""); + static_cast<const AggregationHandleMin &>(*aggregation_handle_min_float) + .iterateUnaryInl(static_cast<AggregationStateMin *>( + aggregation_state_min_merge_float.get()), + float_type.makeValue(&float_val)); + EXPECT_DEATH( + aggregation_handle_min_->mergeStates(*aggregation_state_min_merge_float, + aggregation_handle_min_state_.get()), + ""); } #endif @@ -643,25 +685,28 @@ TEST_F(AggregationHandleMinTest, GroupByTableMergeTest) { initializeHandle(int_non_null_type); storage_manager_.reset(new StorageManager("./test_min_data")); std::unique_ptr<AggregationStateHashTableBase> source_hash_table( - aggregation_handle_min_->createGroupByHashTable( - HashTableImplType::kSimpleScalarSeparateChaining, + AggregationStateFastHashTableFactory::CreateResizable( + HashTableImplType::kSeparateChaining, std::vector<const Type *>(1, &int_non_null_type), 10, + {aggregation_handle_min_.get()->getPayloadSize()}, + {aggregation_handle_min_.get()}, storage_manager_.get())); std::unique_ptr<AggregationStateHashTableBase> destination_hash_table( - aggregation_handle_min_->createGroupByHashTable( - HashTableImplType::kSimpleScalarSeparateChaining, + AggregationStateFastHashTableFactory::CreateResizable( + HashTableImplType::kSeparateChaining, std::vector<const Type *>(1, &int_non_null_type), 10, + {aggregation_handle_min_.get()->getPayloadSize()}, + {aggregation_handle_min_.get()}, storage_manager_.get())); - AggregationStateHashTable<AggregationStateMin> *destination_hash_table_derived = - static_cast<AggregationStateHashTable<AggregationStateMin> *>( + AggregationStateFastHashTable *destination_hash_table_derived = + static_cast<AggregationStateFastHashTable *>( destination_hash_table.get()); - AggregationStateHashTable<AggregationStateMin> *source_hash_table_derived = - static_cast<AggregationStateHashTable<AggregationStateMin> *>( - source_hash_table.get()); + AggregationStateFastHashTable *source_hash_table_derived = + static_cast<AggregationStateFastHashTable *>(source_hash_table.get()); AggregationHandleMin *aggregation_handle_min_derived = static_cast<AggregationHandleMin *>(aggregation_handle_min_.get()); @@ -726,35 +771,52 @@ TEST_F(AggregationHandleMinTest, GroupByTableMergeTest) { EXPECT_EQ(exclusive_key_source_min_val.getLiteral<int>(), actual_val); // Add the key-state pairs to the hash tables. - source_hash_table_derived->putCompositeKey(common_key, - *common_key_source_state); - destination_hash_table_derived->putCompositeKey( - common_key, *common_key_destination_state); - source_hash_table_derived->putCompositeKey(exclusive_source_key, - *exclusive_key_source_state); - destination_hash_table_derived->putCompositeKey( - exclusive_destination_key, *exclusive_key_destination_state); + unsigned char buffer[100]; + buffer[0] = '\0'; + memcpy(buffer + 1, + common_key_source_state.get()->getPayloadAddress(), + aggregation_handle_min_.get()->getPayloadSize()); + source_hash_table_derived->putCompositeKey(common_key, buffer); + + memcpy(buffer + 1, + common_key_destination_state.get()->getPayloadAddress(), + aggregation_handle_min_.get()->getPayloadSize()); + destination_hash_table_derived->putCompositeKey(common_key, buffer); + + memcpy(buffer + 1, + exclusive_key_source_state.get()->getPayloadAddress(), + aggregation_handle_min_.get()->getPayloadSize()); + source_hash_table_derived->putCompositeKey(exclusive_source_key, buffer); + + memcpy(buffer + 1, + exclusive_key_destination_state.get()->getPayloadAddress(), + aggregation_handle_min_.get()->getPayloadSize()); + destination_hash_table_derived->putCompositeKey(exclusive_destination_key, + buffer); EXPECT_EQ(2u, destination_hash_table_derived->numEntries()); EXPECT_EQ(2u, source_hash_table_derived->numEntries()); - aggregation_handle_min_->mergeGroupByHashTables(*source_hash_table, - destination_hash_table.get()); + AggregationOperationState::mergeGroupByHashTables( + source_hash_table.get(), destination_hash_table.get()); EXPECT_EQ(3u, destination_hash_table_derived->numEntries()); CheckMinValue<int>( common_key_source_min_val.getLiteral<int>(), - *aggregation_handle_min_derived, - *(destination_hash_table_derived->getSingleCompositeKey(common_key))); + aggregation_handle_min_derived->finalizeHashTableEntryFast( + destination_hash_table_derived->getSingleCompositeKey(common_key) + + 1)); CheckMinValue<int>(exclusive_key_destination_min_val.getLiteral<int>(), - *aggregation_handle_min_derived, - *(destination_hash_table_derived->getSingleCompositeKey( - exclusive_destination_key))); + aggregation_handle_min_derived->finalizeHashTableEntryFast( + destination_hash_table_derived->getSingleCompositeKey( + exclusive_destination_key) + + 1)); CheckMinValue<int>(exclusive_key_source_min_val.getLiteral<int>(), - *aggregation_handle_min_derived, - *(source_hash_table_derived->getSingleCompositeKey( - exclusive_source_key))); + aggregation_handle_min_derived->finalizeHashTableEntryFast( + source_hash_table_derived->getSingleCompositeKey( + exclusive_source_key) + + 1)); } } // namespace quickstep