| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| **/ |
| |
| #include <algorithm> |
| #include <cstddef> |
| #include <cstdint> |
| #include <limits> |
| #include <memory> |
| #include <set> |
| #include <sstream> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "catalog/CatalogAttribute.hpp" |
| #include "catalog/CatalogRelation.hpp" |
| #include "catalog/CatalogTypedefs.hpp" |
| #include "expressions/predicate/ComparisonPredicate.hpp" |
| #include "expressions/predicate/PredicateCost.hpp" |
| #include "expressions/scalar/ScalarAttribute.hpp" |
| #include "expressions/scalar/ScalarLiteral.hpp" |
| #include "storage/CompressedColumnStoreTupleStorageSubBlock.hpp" |
| #include "storage/SMAIndexSubBlock.hpp" |
| #include "storage/StorageBlockInfo.hpp" |
| #include "storage/StorageBlockLayout.pb.h" |
| #include "storage/TupleIdSequence.hpp" |
| #include "storage/tests/MockTupleStorageSubBlock.hpp" |
| #include "types/CharType.hpp" |
| #include "types/DoubleType.hpp" |
| #include "types/FloatType.hpp" |
| #include "types/IntType.hpp" |
| #include "types/LongType.hpp" |
| #include "types/TypeFactory.hpp" |
| #include "types/TypeID.hpp" |
| #include "types/TypedValue.hpp" |
| #include "types/VarCharType.hpp" |
| #include "types/containers/Tuple.hpp" |
| #include "types/operations/comparisons/Comparison.hpp" |
| #include "types/operations/comparisons/ComparisonFactory.hpp" |
| #include "types/operations/comparisons/ComparisonID.hpp" |
| #include "utility/ScopedBuffer.hpp" |
| |
| #include "glog/logging.h" |
| #include "gtest/gtest.h" |
| |
| using std::binary_search; |
| using std::int64_t; |
| using std::numeric_limits; |
| using std::ostringstream; |
| using std::set; |
| using std::size_t; |
| using std::string; |
| using std::uint8_t; |
| using std::uint16_t; |
| using std::uint32_t; |
| using std::vector; |
| |
| namespace quickstep { |
| |
| typedef sma_internal::EntryReference EntryReference; |
| typedef sma_internal::SMAEntry SMAEntry; |
| typedef sma_internal::SMAPredicate SMAPredicate; |
| typedef sma_internal::Selectivity Selectivity; |
| |
| namespace sma_test { |
| // Handy comparison functions which are used in the unit tests. |
| |
| bool longsEqual(TypedValue left, TypedValue right) { |
| return ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(left, LongType::InstanceNonNullable(), |
| right, LongType::InstanceNonNullable()); |
| } |
| |
| bool floatsEqual(TypedValue left, TypedValue right) { |
| return ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(left, FloatType::InstanceNonNullable(), |
| right, FloatType::InstanceNonNullable()); |
| } |
| |
| bool doublesEqual(TypedValue left, TypedValue right) { |
| return ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(left, DoubleType::InstanceNonNullable(), |
| right, DoubleType::InstanceNonNullable()); |
| } |
| |
| bool charsEqual(TypedValue left, TypedValue right) { |
| return ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(left, CharType::Instance(80, false), |
| right, CharType::Instance(80, false)); |
| } |
| |
| bool varcharsEqual(TypedValue left, TypedValue right) { |
| return ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(left, TypeFactory::GetType(kVarChar, 8, false), |
| right, TypeFactory::GetType(kVarChar, 8, false)); |
| } |
| } // namespace sma_test |
| |
| class SMAIndexSubBlockTest : public ::testing::Test { |
| protected: |
| static const size_t kIndexSubBlockSize = 0x100000; // 1 MB |
| // Hack: replace long_attr values equal to this with NULL. |
| static const int64_t kLongAttrNullValue = -55555; |
| static const char kCharAttrNullValue[]; |
| |
| virtual void SetUp() { |
| // Create a sample relation with a variety of attribute types. |
| relation_.reset(new CatalogRelation(NULL, "TestRelation")); |
| |
| CatalogAttribute *long_attr = new CatalogAttribute(relation_.get(), |
| "long_attr", |
| TypeFactory::GetType(kLong, false)); |
| ASSERT_EQ(0, relation_->addAttribute(long_attr)); |
| |
| CatalogAttribute *nullable_long_attr = new CatalogAttribute(relation_.get(), |
| "nullable_long_attr", |
| TypeFactory::GetType(kLong, true)); |
| ASSERT_EQ(1, relation_->addAttribute(nullable_long_attr)); |
| |
| CatalogAttribute *float_attr = new CatalogAttribute(relation_.get(), |
| "float_attr", |
| TypeFactory::GetType(kFloat, false)); |
| ASSERT_EQ(2, relation_->addAttribute(float_attr)); |
| |
| CatalogAttribute *char_attr = new CatalogAttribute(relation_.get(), |
| "char_attr", |
| TypeFactory::GetType(kChar, 4, false)); |
| ASSERT_EQ(3, relation_->addAttribute(char_attr)); |
| |
| CatalogAttribute *nullable_char_attr = new CatalogAttribute(relation_.get(), |
| "nullable_char_attr", |
| TypeFactory::GetType(kChar, 4, true)); |
| ASSERT_EQ(4, relation_->addAttribute(nullable_char_attr)); |
| |
| CatalogAttribute *big_char_attr = new CatalogAttribute(relation_.get(), |
| "big_char_attr", |
| TypeFactory::GetType(kChar, 80, false)); |
| ASSERT_EQ(5, relation_->addAttribute(big_char_attr)); |
| |
| CatalogAttribute *varchar_attr = new CatalogAttribute(relation_.get(), |
| "varchar_attr", |
| TypeFactory::GetType(kVarChar, 8, false)); |
| ASSERT_EQ(6, relation_->addAttribute(varchar_attr)); |
| |
| // Create a MockTupleStorageSubBlock to hold tuples for testing. |
| tuple_store_.reset(new MockTupleStorageSubBlock(*relation_)); |
| |
| // Don't initialize the SMAIndexSubBlock yet. Different tests will |
| // index on different attributes. |
| index_memory_.reset(); |
| index_description_.reset(); |
| index_.reset(); |
| } |
| |
| void createIndex(const vector<attribute_id> &indexed_attrs, const size_t index_memory_size) { |
| // Make the IndexSubBlockDescription. |
| index_description_.reset(new IndexSubBlockDescription()); |
| index_description_->set_sub_block_type(IndexSubBlockDescription::SMA); |
| for (std::size_t i = 0; i < indexed_attrs.size(); ++i) { |
| index_description_->add_indexed_attribute_ids(indexed_attrs[i]); |
| } |
| index_memory_.reset(index_memory_size); |
| index_.reset(new SMAIndexSubBlock(*tuple_store_, |
| *index_description_, |
| true, |
| index_memory_.get(), |
| index_memory_size)); |
| } |
| |
| // Insert a tuple with the specified attribute values into tuple_store_. |
| tuple_id insertTupleInTupleStore(const int64_t long_val, |
| const int64_t nullable_long_val, |
| const float float_val, |
| const string &char_val, |
| const string &nullable_char_val, |
| const string &big_char_val, |
| const string &varchar_val) { |
| std::vector<TypedValue> attrs; |
| |
| attrs.emplace_back(LongType::InstanceNonNullable().makeValue(&long_val)); |
| |
| if (nullable_long_val == kLongAttrNullValue) { |
| attrs.emplace_back(LongType::InstanceNullable().makeNullValue()); |
| } else { |
| attrs.emplace_back(LongType::InstanceNullable().makeValue(&nullable_long_val)); |
| } |
| |
| attrs.emplace_back(FloatType::InstanceNonNullable().makeValue(&float_val)); |
| |
| attrs.emplace_back(CharType::InstanceNonNullable(4).makeValue( |
| char_val.c_str(), |
| char_val.size() >= 4 ? 4 : char_val.size() + 1).ensureNotReference()); |
| |
| if (nullable_char_val == kCharAttrNullValue) { |
| attrs.emplace_back(CharType::InstanceNullable(4).makeNullValue()); |
| } else { |
| attrs.emplace_back(CharType::InstanceNonNullable(4).makeValue( |
| nullable_char_val.c_str(), |
| nullable_char_val.size() >= 4 ? 4 : nullable_char_val.size() + 1).ensureNotReference()); |
| } |
| |
| attrs.emplace_back(CharType::InstanceNonNullable(80).makeValue( |
| big_char_val.c_str(), |
| big_char_val.size() >= 80 ? 80 : big_char_val.size() + 1).ensureNotReference()); |
| |
| TypedValue varchar_typed_value |
| = VarCharType::InstanceNonNullable(varchar_val.size()).makeValue( |
| varchar_val.c_str(), |
| varchar_val.size() + 1); |
| // Test strings are sometimes longer than 8 characters, so truncate if |
| // needed. |
| varchar_typed_value = VarCharType::InstanceNonNullable(8).coerceValue( |
| varchar_typed_value, |
| VarCharType::InstanceNonNullable(varchar_val.size())); |
| varchar_typed_value.ensureNotReference(); |
| attrs.emplace_back(std::move(varchar_typed_value)); |
| |
| // MockTupleStorageSubBlock takes ownership of new tuple passed in with |
| // addTupleMock() method. |
| return tuple_store_->addTupleMock(new Tuple(std::move(attrs))); |
| } |
| |
| // Generate a sample tuple based on 'base_value' and insert in into |
| // tuple_store_. The sample tuple will have long_attr equal to 'base_value', |
| // float_attr equal to 0.25 * base_value, and each of char_attr, |
| // big_char_attr, and varchar_attr equal to the string representation of |
| // 'base_value' with 'string_suffix' appended on to it. If 'generate_nulls' |
| // is true, then both nullable_long_attr and nullable_char_attr will be NULL, |
| // otherwise nullable_long_attr will be equal to 'base_value' and |
| // nullable_char_attr will be equal to the other string values. Returns the |
| // tuple_id of the inserted tuple. |
| tuple_id generateAndInsertTuple(const int64_t base_value, |
| const bool generate_nulls, |
| const string &string_suffix) { |
| ostringstream string_value_buffer; |
| string_value_buffer << base_value << string_suffix; |
| if (generate_nulls) { |
| return insertTupleInTupleStore(base_value, |
| kLongAttrNullValue, |
| 0.25 * base_value, |
| string_value_buffer.str(), |
| kCharAttrNullValue, |
| string_value_buffer.str(), |
| string_value_buffer.str()); |
| } else { |
| return insertTupleInTupleStore(base_value, |
| base_value, |
| 0.25 * base_value, |
| string_value_buffer.str(), |
| string_value_buffer.str(), |
| string_value_buffer.str(), |
| string_value_buffer.str()); |
| } |
| } |
| |
| // Create a ComparisonPredicate of the form "attribute comp literal". |
| template <typename AttributeType> |
| ComparisonPredicate* generateNumericComparisonPredicate( |
| const ComparisonID comp, |
| const attribute_id attribute, |
| const typename AttributeType::cpptype literal) { |
| ScalarAttribute *scalar_attribute = new ScalarAttribute(*relation_->getAttributeById(attribute)); |
| ScalarLiteral *scalar_literal |
| = new ScalarLiteral(AttributeType::InstanceNonNullable().makeValue(&literal), |
| AttributeType::InstanceNonNullable()); |
| return new ComparisonPredicate(ComparisonFactory::GetComparison(comp), scalar_attribute, scalar_literal); |
| } |
| |
| ComparisonPredicate* generateStringComparisonPredicate( |
| const ComparisonID comp, |
| const attribute_id attribute, |
| const string &literal) { |
| ScalarAttribute *scalar_attribute = new ScalarAttribute(*relation_->getAttributeById(attribute)); |
| ScalarLiteral *scalar_literal = new ScalarLiteral( |
| VarCharType::InstanceNonNullable(literal.size()).makeValue( |
| literal.c_str(), |
| literal.size() + 1).ensureNotReference(), |
| VarCharType::InstanceNonNullable(literal.size())); |
| return new ComparisonPredicate(ComparisonFactory::GetComparison(comp), scalar_attribute, scalar_literal); |
| } |
| |
| // Retrieves the SMAEntry from the test SMAIndex instance. |
| SMAEntry* getEntryForAttribute(attribute_id attribute) { |
| return const_cast<SMAEntry*>(index_->getEntryChecked(attribute)); |
| } |
| |
| bool requiresRebuild() const { |
| CHECK(index_) << "SMA not yet built!"; |
| return !index_->header_->index_consistent; |
| } |
| |
| Selectivity getSelectivityForPredicate(const ComparisonPredicate &predicate) const { |
| return index_->getSelectivityForPredicate(predicate); |
| } |
| |
| std::unique_ptr<CatalogRelation> relation_; |
| std::unique_ptr<MockTupleStorageSubBlock> tuple_store_; |
| ScopedBuffer index_memory_; |
| std::unique_ptr<IndexSubBlockDescription> index_description_; |
| std::unique_ptr<SMAIndexSubBlock> index_; |
| }; |
| |
| const char SMAIndexSubBlockTest::kCharAttrNullValue[] = "_NULLSTRING"; |
| |
| TEST_F(SMAIndexSubBlockTest, DescriptionIsValidTest) { |
| std::unique_ptr<IndexSubBlockDescription> index_description_; |
| // valid_attrs contains attribute ids which should register as |
| // a valid DescriptionIsValid. |
| vector<attribute_id> valid_attrs({0, 1, 2, 3, 4, 5, 6}); |
| // Try to create an index on each of the attributes. Make sure that each |
| // of the attributes which can be indexed on is marked valid. |
| for (const CatalogAttribute &attr : *relation_) { |
| index_description_.reset( |
| new IndexSubBlockDescription()); |
| index_description_->set_sub_block_type( |
| IndexSubBlockDescription::SMA); |
| index_description_->add_indexed_attribute_ids(attr.getID()); |
| if (std::find(valid_attrs.begin(), valid_attrs.end(), attr.getID()) != valid_attrs.end()) { |
| EXPECT_TRUE(SMAIndexSubBlock::DescriptionIsValid( |
| *relation_, |
| *index_description_)) |
| << "Expected attribute " << attr.getID() << " to be valid."; |
| } else { |
| EXPECT_FALSE(SMAIndexSubBlock::DescriptionIsValid( |
| *relation_, |
| *index_description_)) |
| << "Expected attribute " << attr.getID() << " to be invalid."; |
| } |
| } |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestConstructor) { |
| // Calling this method has the side effect of creating an index description |
| // which is the real reason for calling createIndex here. |
| createIndex({0, 1, 2}, kIndexSubBlockSize); |
| |
| EXPECT_TRUE(requiresRebuild()); |
| EXPECT_TRUE(index_->rebuild()); |
| EXPECT_FALSE(requiresRebuild()); |
| |
| // Reset will cause the Index to go through its delete routine. |
| index_.reset(nullptr); |
| |
| // Creating a block on the same memory should cause the index to retrieve |
| // the previously written values. |
| index_.reset(new SMAIndexSubBlock(*tuple_store_, |
| *index_description_, |
| false, |
| index_memory_.get(), |
| kIndexSubBlockSize)); |
| EXPECT_FALSE(requiresRebuild()); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestGetSelectivityForPredicate) { |
| // Index long, float, bigchar, and varchar type. |
| createIndex({0, 2, 5, 6}, kIndexSubBlockSize); |
| int min = 0, max = 9010, step = 10; |
| for (std::size_t i = min; i <= static_cast<std::size_t>(max); i += step) { |
| generateAndInsertTuple(i, false, "suffix"); |
| } |
| index_->rebuild(); |
| |
| // Tuple storage block now contains long values [0, 9010], and float values |
| // [0, 2252.5]. |
| // Test several value types. |
| // Test with inline values, returning both possible value types. |
| std::unique_ptr<ComparisonPredicate> predicate( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, min)); |
| Selectivity cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kNone, cost); |
| |
| // Test on the float attribute with a type that will need coercion. In this |
| // case, a long type should not coerce to an integer type. |
| predicate.reset(generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 2, min)); |
| cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kUnknown, cost); |
| |
| predicate.reset(generateNumericComparisonPredicate<IntType>(ComparisonID::kLess, 2, min)); |
| cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kNone, cost); |
| |
| // This should be unknown because of the loss of precision on coercion. |
| predicate.reset(generateNumericComparisonPredicate<FloatType>(ComparisonID::kLess, 0, min + 0.5)); |
| cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kUnknown, cost); |
| |
| // Test coercion with String types as well. |
| predicate.reset(generateStringComparisonPredicate(ComparisonID::kLess, 6, "")); |
| cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kNone, cost); |
| |
| predicate.reset(generateStringComparisonPredicate(ComparisonID::kLess, 5, "")); |
| cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kNone, cost); |
| |
| predicate.reset(generateStringComparisonPredicate(ComparisonID::kLess, 5, "999999999999999")); |
| cost = getSelectivityForPredicate(*predicate); |
| EXPECT_EQ(Selectivity::kAll, cost); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestRebuild) { |
| // This test is checking to see if the min/max values are set correctly on |
| // a rebuild of the index. |
| // Index long, float type. |
| createIndex({0, 2}, kIndexSubBlockSize); |
| int min = 0, max = 9010, step = 10; |
| std::int64_t sum_0 = 0; |
| double sum_2 = 0; |
| for (std::size_t i = min; i <= static_cast<std::size_t>(max); i += step) { |
| generateAndInsertTuple(i, false, "suffix"); |
| sum_0 += i; |
| sum_2 += (i * 0.25); |
| } |
| index_->rebuild(); |
| SMAEntry* entry0 = getEntryForAttribute(0); |
| SMAEntry* entry2 = getEntryForAttribute(2); |
| // Entries should and must exist. |
| ASSERT_TRUE(entry0 != nullptr && entry2 != nullptr); |
| |
| // Check entry validity. |
| EXPECT_TRUE(entry0->min_entry_ref.valid); |
| EXPECT_TRUE(entry2->min_entry_ref.valid); |
| EXPECT_TRUE(entry0->max_entry_ref.valid); |
| EXPECT_TRUE(entry2->max_entry_ref.valid); |
| |
| // Check min ids and values. |
| EXPECT_EQ(0, entry0->min_entry_ref.entry_ref_tuple); |
| EXPECT_EQ(0, entry2->min_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::longsEqual(entry0->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(0, 0))); |
| |
| EXPECT_TRUE(sma_test::floatsEqual(entry2->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(0, 2))); |
| |
| // Check max ids and values. |
| tuple_id max_id = (max - min)/step; |
| EXPECT_EQ(max_id, entry0->max_entry_ref.entry_ref_tuple); |
| EXPECT_EQ(max_id, entry2->max_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::longsEqual(entry0->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(max_id, 0))); |
| EXPECT_TRUE(sma_test::floatsEqual(entry2->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(max_id, 2))); |
| |
| // Check sums. |
| EXPECT_TRUE(sma_test::longsEqual(entry0->sum_aggregate, TypedValue(sum_0))); |
| EXPECT_TRUE(sma_test::doublesEqual(entry2->sum_aggregate, TypedValue(sum_2))); |
| |
| // Check count. This count includes nulls (it's the count of the total # of rows). |
| EXPECT_EQ(static_cast<std::size_t>(max_id + 1), index_->getCount()); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestRebuildWithNulls) { |
| // Check that building an index with nullable attributes and null values |
| // behvaes correctly. |
| |
| createIndex({0, 1, 2}, kIndexSubBlockSize); |
| int min = 0, max = 9010, step = 10; |
| |
| // Attribute 1 will contain some nulls so keep its sum while inserting tuples. |
| std::int64_t sum_1 = 0; |
| for (std::size_t i = min; i <= static_cast<std::size_t>(max); i += step) { |
| bool insertNull = (i % 4) == 0; |
| generateAndInsertTuple(i, insertNull, "suffix"); |
| sum_1 += insertNull ? 0 : i; |
| } |
| bool rebuild_status = index_->rebuild(); |
| ASSERT_TRUE(rebuild_status); |
| |
| SMAEntry* entry1 = getEntryForAttribute(1); |
| EXPECT_TRUE(entry1->min_entry_ref.valid); |
| |
| // Check min ids and values. |
| tuple_id min_tuple = 1; |
| EXPECT_EQ(min_tuple, entry1->min_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::longsEqual(entry1->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(min_tuple, 1))); |
| |
| // Check max ids and values. |
| int num_tuples = (max - min)/step + 1; |
| // The math figures out what the max tuple id is (sometimes the expected max will be null). |
| tuple_id max_tuple = ((num_tuples - 1) % 4) == 0 ? num_tuples - 2 : num_tuples - 1; |
| EXPECT_EQ(max_tuple, entry1->max_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::longsEqual(entry1->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(max_tuple, 1))); |
| |
| // Check sums. |
| EXPECT_TRUE(sma_test::longsEqual(entry1->sum_aggregate, TypedValue(sum_1))); |
| |
| // Check count. |
| EXPECT_EQ(static_cast<std::size_t>(num_tuples), index_->getCount()); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestWithVariableLengthAttrs) { |
| // Create an index on nullable char, BigChar, VarChar. |
| createIndex({4, 5, 6}, kIndexSubBlockSize); |
| int min = 0, max = 1001; |
| tuple_id max_id, min_id; |
| |
| // These are to keep track of the smallest and largest strings inserted |
| // into the relation. |
| std::string suffix("suffix"); |
| std::string max_str(""); |
| std::string min_str("Z"); |
| for (std::size_t i = min; i < static_cast<std::size_t>(max); ++i) { |
| tuple_id id = generateAndInsertTuple(i, false, suffix); |
| |
| // Keep track of the min/max strings entered. |
| ostringstream string_value_buffer; |
| string_value_buffer << i << suffix; |
| if (string_value_buffer.str() < min_str) { |
| min_str = string_value_buffer.str(); |
| min_id = id; |
| } |
| if (string_value_buffer.str() > max_str) { |
| max_str = string_value_buffer.str(); |
| max_id = id; |
| } |
| } |
| |
| EXPECT_TRUE(index_->hasEntryForAttribute(4)); |
| EXPECT_TRUE(index_->hasEntryForAttribute(5)); |
| EXPECT_TRUE(index_->hasEntryForAttribute(6)); |
| EXPECT_TRUE(index_->rebuild()); |
| |
| // Test attribute 4, a nullable 4 character char. |
| SMAEntry* nullable_char_entry_4 = getEntryForAttribute(4); |
| EXPECT_EQ(kChar, nullable_char_entry_4->type_id); |
| EXPECT_EQ(4, nullable_char_entry_4->attribute); |
| |
| // Min and Max values should be valid at this point. |
| EXPECT_TRUE(nullable_char_entry_4->max_entry_ref.valid); |
| EXPECT_TRUE(nullable_char_entry_4->min_entry_ref.valid); |
| |
| // Check min ids and values. |
| EXPECT_EQ(min_id, nullable_char_entry_4->min_entry_ref.entry_ref_tuple); |
| EXPECT_EQ(max_id, nullable_char_entry_4->max_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::charsEqual( |
| nullable_char_entry_4->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(nullable_char_entry_4->min_entry_ref.entry_ref_tuple, 4))); |
| |
| EXPECT_TRUE(sma_test::charsEqual( |
| nullable_char_entry_4->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(nullable_char_entry_4->max_entry_ref.entry_ref_tuple, 4))); |
| |
| // Test attribute 5, an 80 character char. |
| SMAEntry* char_entry_5 = getEntryForAttribute(5); |
| EXPECT_EQ(kChar, char_entry_5->type_id); |
| EXPECT_EQ(5, char_entry_5->attribute); |
| |
| // Min and Max values should be valid at this point. |
| EXPECT_TRUE(char_entry_5->max_entry_ref.valid); |
| EXPECT_TRUE(char_entry_5->min_entry_ref.valid); |
| |
| // Check min ids and values. |
| EXPECT_EQ(min_id, char_entry_5->min_entry_ref.entry_ref_tuple); |
| EXPECT_EQ(max_id, char_entry_5->max_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::charsEqual( |
| char_entry_5->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(char_entry_5->min_entry_ref.entry_ref_tuple, 5))); |
| |
| EXPECT_TRUE(sma_test::charsEqual( |
| char_entry_5->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(char_entry_5->max_entry_ref.entry_ref_tuple, 5))); |
| |
| // Test attribute 6, an 8 character varchar. |
| SMAEntry* varchar_entry_6 = getEntryForAttribute(6); |
| EXPECT_EQ(kVarChar, varchar_entry_6->type_id); |
| EXPECT_EQ(6, varchar_entry_6->attribute); |
| |
| // Min and Max values should be valid at this point. |
| EXPECT_TRUE(varchar_entry_6->max_entry_ref.valid); |
| EXPECT_TRUE(varchar_entry_6->min_entry_ref.valid); |
| |
| // Check min ids and values. |
| EXPECT_EQ(min_id, varchar_entry_6->min_entry_ref.entry_ref_tuple); |
| EXPECT_EQ(max_id, varchar_entry_6->max_entry_ref.entry_ref_tuple); |
| EXPECT_TRUE(sma_test::varcharsEqual( |
| varchar_entry_6->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(varchar_entry_6->min_entry_ref.entry_ref_tuple, 6))); |
| |
| EXPECT_TRUE(sma_test::varcharsEqual( |
| varchar_entry_6->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(varchar_entry_6->max_entry_ref.entry_ref_tuple, 6))); |
| |
| // Try kicking the index out of memory and then getting the variable length |
| // attributes back. |
| // We must call the destructor before attempting to create an index over the same memory. |
| index_.reset(nullptr); |
| index_.reset(new SMAIndexSubBlock(*tuple_store_, |
| *index_description_, |
| false, |
| index_memory_.get(), |
| kIndexSubBlockSize)); |
| ASSERT_FALSE(requiresRebuild()); |
| |
| // Ensure that the attributes are as they were before the rebuild process. |
| EXPECT_EQ(kChar, getEntryForAttribute(4)->type_id); |
| |
| SMAEntry* rebuilt_entry6 = getEntryForAttribute(6); |
| EXPECT_EQ(kVarChar, rebuilt_entry6->type_id); |
| EXPECT_EQ(6, rebuilt_entry6->attribute); |
| EXPECT_TRUE(rebuilt_entry6->min_entry_ref.valid); |
| EXPECT_TRUE(rebuilt_entry6->max_entry_ref.valid); |
| EXPECT_EQ(min_id, rebuilt_entry6->min_entry_ref.entry_ref_tuple); |
| EXPECT_EQ(max_id, rebuilt_entry6->max_entry_ref.entry_ref_tuple); |
| ASSERT_EQ(kVarChar, rebuilt_entry6->max_entry_ref.value.getTypeID()); |
| ASSERT_EQ(kVarChar, rebuilt_entry6->min_entry_ref.value.getTypeID()); |
| EXPECT_TRUE(sma_test::varcharsEqual( |
| rebuilt_entry6->min_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(rebuilt_entry6->min_entry_ref.entry_ref_tuple, 6))); |
| EXPECT_TRUE(sma_test::varcharsEqual( |
| rebuilt_entry6->max_entry_ref.value, |
| tuple_store_->getAttributeValueTyped(rebuilt_entry6->max_entry_ref.entry_ref_tuple, 6))); |
| |
| // Check count. |
| EXPECT_EQ(static_cast<std::size_t>(max), index_->getCount()); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestWithCompressedColumnStore) { |
| // Create a relation with just a single attribute, which will be compressed. |
| relation_.reset(new CatalogRelation(NULL, "TestRelation")); |
| CatalogAttribute *truncated_long_attr = new CatalogAttribute(relation_.get(), |
| "truncated_long_attr", |
| TypeFactory::GetType(kLong, false)); |
| ASSERT_EQ(0, relation_->addAttribute(truncated_long_attr)); |
| |
| CatalogAttribute *compressed_string_attr = new CatalogAttribute(relation_.get(), |
| "compressed_string_attr", |
| TypeFactory::GetType(kVarChar, 80, false)); |
| ASSERT_EQ(1, relation_->addAttribute(compressed_string_attr)); |
| |
| // Create a CompressedPackedRowStoreTupleStorageSubBlock. |
| std::unique_ptr<TupleStorageSubBlockDescription> tuple_store_description(new TupleStorageSubBlockDescription()); |
| tuple_store_description->set_sub_block_type(TupleStorageSubBlockDescription::COMPRESSED_COLUMN_STORE); |
| tuple_store_description->SetExtension( |
| CompressedColumnStoreTupleStorageSubBlockDescription::sort_attribute_id, 0); |
| for (attribute_id attr_id = 0; attr_id < 2; ++attr_id) { |
| tuple_store_description->AddExtension( |
| CompressedColumnStoreTupleStorageSubBlockDescription::compressed_attribute_id, |
| attr_id); |
| } |
| |
| ScopedBuffer compressed_tuple_store_memory(kIndexSubBlockSize); |
| std::unique_ptr<CompressedColumnStoreTupleStorageSubBlock> compressed_tuple_store( |
| new CompressedColumnStoreTupleStorageSubBlock( |
| *relation_, |
| *tuple_store_description, |
| true, |
| compressed_tuple_store_memory.get(), |
| kIndexSubBlockSize)); |
| |
| // Create an index on the compressed tuple store. |
| IndexSubBlockDescription compressed_index_description; |
| compressed_index_description.set_sub_block_type(IndexSubBlockDescription::SMA); |
| compressed_index_description.add_indexed_attribute_ids(0); |
| compressed_index_description.add_indexed_attribute_ids(1); |
| |
| // Compressed blocks should be valid. |
| ASSERT_TRUE(SMAIndexSubBlock::DescriptionIsValid(*relation_, compressed_index_description)); |
| |
| // Add some values to the compressed store. |
| std::string max_varchar_string("0"); |
| for (int tuple_num = 0; tuple_num < 400; ++tuple_num) { |
| int tuple_val = tuple_num % 100; |
| std::vector<TypedValue> attrs; |
| attrs.emplace_back(static_cast<int64_t>(tuple_val)); |
| |
| std::string varchar_val = std::to_string(tuple_val); |
| varchar_val.append("suffix"); |
| TypedValue varchar_typed_value |
| = VarCharType::InstanceNonNullable(varchar_val.size()).makeValue( |
| varchar_val.c_str(), |
| varchar_val.size() + 1); |
| |
| // Keep track of the largest varchar. |
| if (varchar_val > max_varchar_string) { |
| max_varchar_string = varchar_val; |
| } |
| |
| attrs.emplace_back(varchar_typed_value); |
| ASSERT_TRUE(compressed_tuple_store->insertTupleInBatch(Tuple(std::move(attrs)))); |
| } |
| |
| // Build the tuple-store. |
| compressed_tuple_store->rebuild(); |
| EXPECT_FALSE(compressed_tuple_store->compressedAttributeIsDictionaryCompressed(0)); |
| EXPECT_TRUE(compressed_tuple_store->compressedAttributeIsTruncationCompressed(0)); |
| |
| EXPECT_TRUE(compressed_tuple_store->compressedAttributeIsDictionaryCompressed(1)); |
| EXPECT_FALSE(compressed_tuple_store->compressedAttributeIsTruncationCompressed(1)); |
| |
| // Build the index. |
| index_memory_.reset(kIndexSubBlockSize); |
| index_.reset(new SMAIndexSubBlock(*compressed_tuple_store, |
| compressed_index_description, |
| true, |
| index_memory_.get(), |
| kIndexSubBlockSize)); |
| |
| index_->rebuild(); |
| |
| // Test variable length attribute.. |
| SMAEntry* entry1 = getEntryForAttribute(1); |
| EXPECT_EQ(kVarChar, entry1->type_id); |
| EXPECT_EQ(1, entry1->attribute); |
| |
| // Min and Max values should be valid at this point. |
| EXPECT_TRUE(entry1->max_entry_ref.valid); |
| EXPECT_TRUE(entry1->min_entry_ref.valid); |
| |
| // Check min ids and values. |
| EXPECT_TRUE(sma_test::varcharsEqual( |
| entry1->min_entry_ref.value, |
| compressed_tuple_store->getAttributeValueTyped(entry1->min_entry_ref.entry_ref_tuple, 1))); |
| |
| EXPECT_TRUE(sma_test::varcharsEqual( |
| entry1->max_entry_ref.value, |
| compressed_tuple_store->getAttributeValueTyped(entry1->max_entry_ref.entry_ref_tuple, 1))); |
| |
| TypedValue max_varchar_typedvalue |
| = VarCharType::InstanceNonNullable(max_varchar_string.size()).makeValue( |
| max_varchar_string.c_str(), |
| max_varchar_string.size() + 1); |
| |
| EXPECT_TRUE(ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(max_varchar_typedvalue, TypeFactory::GetType(kVarChar, 80, false), |
| entry1->max_entry_ref.value, TypeFactory::GetType(kVarChar, 80, false))); |
| |
| // Test inline attribute.. |
| SMAEntry* entry0 = getEntryForAttribute(0); |
| EXPECT_EQ(kLong, entry0->type_id); |
| EXPECT_EQ(0, entry0->attribute); |
| |
| // Min and Max values should be valid at this point. |
| EXPECT_TRUE(entry0->max_entry_ref.valid); |
| EXPECT_TRUE(entry0->min_entry_ref.valid); |
| |
| // Check min ids and values. |
| EXPECT_TRUE(sma_test::longsEqual( |
| entry0->min_entry_ref.value, |
| compressed_tuple_store->getAttributeValueTyped(entry0->min_entry_ref.entry_ref_tuple, 0))); |
| |
| EXPECT_TRUE(sma_test::longsEqual( |
| entry0->max_entry_ref.value, |
| compressed_tuple_store->getAttributeValueTyped(entry0->max_entry_ref.entry_ref_tuple, 0))); |
| |
| TypedValue max_long_typedvalue(static_cast<int64_t>(99)); |
| |
| EXPECT_TRUE(ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .compareTypedValuesChecked(max_long_typedvalue, TypeFactory::GetType(kLong, false), |
| entry0->max_entry_ref.value, TypeFactory::GetType(kLong, false))); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestExtractComparison) { |
| // Test for comparison extraction: getting the comparison to a format which |
| // the index can compute on. |
| const attribute_id indexed_attr = 0; |
| const std::int64_t comparison_lit = 123; |
| // The helper 'generate' function creates predicates of the form 'attribute comparison literal'. |
| // These will not require the SMA to flip the comparison. |
| std::unique_ptr<ComparisonPredicate> predicate( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kEqual, indexed_attr, comparison_lit)); |
| std::unique_ptr<SMAPredicate> smapredicate(SMAPredicate::ExtractSMAPredicate(*predicate)); |
| |
| EXPECT_EQ(indexed_attr, smapredicate->attribute); |
| EXPECT_EQ(ComparisonID::kEqual, smapredicate->comparison); |
| EXPECT_EQ(comparison_lit, smapredicate->literal.getLiteral<std::int64_t>()); |
| |
| // Test against a comparison which it might flip (less->greater). |
| predicate.reset(generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, indexed_attr, comparison_lit)); |
| smapredicate.reset(); |
| smapredicate.reset(SMAPredicate::ExtractSMAPredicate(*predicate)); |
| |
| EXPECT_EQ(indexed_attr, smapredicate->attribute); |
| EXPECT_EQ(ComparisonID::kLess, smapredicate->comparison); |
| EXPECT_EQ(comparison_lit, smapredicate->literal.getLiteral<std::int64_t>()); |
| |
| // We must test the case where the SMA must flip the predicate. |
| // Make a comparison of the form 'literal comparison attribute'. |
| ScalarAttribute *scalar_attribute = new ScalarAttribute(*relation_->getAttributeById(indexed_attr)); |
| ScalarLiteral *scalar_literal |
| = new ScalarLiteral(LongType::InstanceNonNullable().makeValue(&comparison_lit), |
| LongType::InstanceNonNullable()); |
| predicate.reset(); |
| predicate.reset(new ComparisonPredicate( |
| ComparisonFactory::GetComparison(ComparisonID::kGreater), scalar_literal, scalar_attribute)); |
| smapredicate.reset(); |
| smapredicate.reset(SMAPredicate::ExtractSMAPredicate(*predicate)); |
| |
| EXPECT_EQ(indexed_attr, smapredicate->attribute); |
| EXPECT_EQ(ComparisonID::kLess, smapredicate->comparison); |
| EXPECT_EQ(comparison_lit, smapredicate->literal.getLiteral<std::int64_t>()); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestGetSelectivity) { |
| // Test to make sure that the selectivity functions behave correctly. |
| // Test with an inline type. |
| std::uint64_t lsmallest = 0, lsmall = 100, lmedium = 1000, llarge = 10000, llargest = 100000; |
| const TypedValue long_smallest = LongType::InstanceNonNullable().makeValue(&lsmallest); |
| const TypedValue long_small = LongType::InstanceNonNullable().makeValue(&lsmall); |
| const TypedValue long_medium = LongType::InstanceNonNullable().makeValue(&lmedium); |
| const TypedValue long_large = LongType::InstanceNonNullable().makeValue(&llarge); |
| const TypedValue long_largest = LongType::InstanceNonNullable().makeValue(&llargest); |
| std::unique_ptr<UncheckedComparator> longs_equal( |
| ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .makeUncheckedComparatorForTypes(LongType::InstanceNonNullable(), LongType::InstanceNonNullable())); |
| std::unique_ptr<UncheckedComparator> longs_less( |
| ComparisonFactory::GetComparison(ComparisonID::kLess) |
| .makeUncheckedComparatorForTypes(LongType::InstanceNonNullable(), LongType::InstanceNonNullable())); |
| |
| // The following tests all use the same test logic. |
| // You can think of this first test as follows: |
| // The first argument of getSelectivity is x, the third is lo, the forth is hi. |
| // What we are testing is if x falls between lo and hi. Since x is set to 'smallest' |
| // the comparison looks something like: |
| // x lo hi |
| // on a number line. |
| // Since x falls outside the range of hi/lo, it should select nothing. |
| |
| // Test with equals. |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(long_smallest, ComparisonID::kEqual, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(long_largest, ComparisonID::kEqual, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_medium, ComparisonID::kEqual, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| |
| // Test with not equals. |
| EXPECT_EQ(Selectivity::kUnknown, |
| sma_internal::getSelectivity(long_smallest, ComparisonID::kNotEqual, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| |
| // Test with less. |
| EXPECT_EQ(Selectivity::kAll, |
| sma_internal::getSelectivity(long_large, ComparisonID::kLess, |
| long_smallest, long_medium, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_large, ComparisonID::kLess, |
| long_smallest, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_largest, ComparisonID::kLess, |
| long_smallest, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(long_medium, ComparisonID::kLess, |
| long_medium, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| // Test with less equals. |
| EXPECT_EQ(Selectivity::kAll, |
| sma_internal::getSelectivity(long_largest, ComparisonID::kLessOrEqual, |
| long_smallest, long_large, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kAll, |
| sma_internal::getSelectivity(long_largest, ComparisonID::kLessOrEqual, |
| long_medium, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_large, ComparisonID::kLessOrEqual, |
| long_smallest, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_medium, ComparisonID::kLessOrEqual, |
| long_medium, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(long_small, ComparisonID::kLessOrEqual, |
| long_medium, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| // Test with greater. |
| EXPECT_EQ(Selectivity::kAll, |
| sma_internal::getSelectivity(long_smallest, ComparisonID::kGreater, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_large, ComparisonID::kGreater, |
| long_smallest, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_smallest, ComparisonID::kGreater, |
| long_smallest, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(long_medium, ComparisonID::kGreater, |
| long_smallest, long_medium, |
| longs_less.get(), longs_equal.get())); |
| |
| // Test with greater or equals. |
| EXPECT_EQ(Selectivity::kAll, |
| sma_internal::getSelectivity(long_smallest, ComparisonID::kGreaterOrEqual, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kAll, |
| sma_internal::getSelectivity(long_medium, ComparisonID::kGreaterOrEqual, |
| long_medium, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_large, ComparisonID::kGreaterOrEqual, |
| long_smallest, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(long_largest, ComparisonID::kGreaterOrEqual, |
| long_medium, long_largest, |
| longs_less.get(), longs_equal.get())); |
| |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(long_largest, ComparisonID::kGreaterOrEqual, |
| long_small, long_large, |
| longs_less.get(), longs_equal.get())); |
| |
| // Now test with variable length attributes. |
| vector<string> str_vals({"avocado", "cruciferous", "fructose", "sauerkraut", "zeppelini"}); |
| vector<TypedValue> str_tvals; |
| for (string &str : str_vals) { |
| str_tvals.push_back( |
| VarCharType::InstanceNonNullable(str.size()).makeValue( |
| str.c_str(), |
| str.size() + 1)); |
| str_tvals.back().ensureNotReference(); |
| } |
| std::unique_ptr<UncheckedComparator> str_equals( |
| ComparisonFactory::GetComparison(ComparisonID::kEqual) |
| .makeUncheckedComparatorForTypes(VarCharType::InstanceNonNullable(16), VarCharType::InstanceNonNullable(16))); |
| std::unique_ptr<UncheckedComparator> str_less( |
| ComparisonFactory::GetComparison(ComparisonID::kLess) |
| .makeUncheckedComparatorForTypes(VarCharType::InstanceNonNullable(16), VarCharType::InstanceNonNullable(16))); |
| |
| // Test with equals. |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(str_tvals[4], ComparisonID::kEqual, |
| str_tvals[0], str_tvals[3], |
| str_less.get(), str_equals.get())); |
| EXPECT_EQ(Selectivity::kNone, |
| sma_internal::getSelectivity(str_tvals[0], ComparisonID::kEqual, |
| str_tvals[1], str_tvals[3], |
| str_less.get(), str_equals.get())); |
| EXPECT_EQ(Selectivity::kSome, |
| sma_internal::getSelectivity(str_tvals[1], ComparisonID::kEqual, |
| str_tvals[0], str_tvals[2], |
| str_less.get(), str_equals.get())); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestEvaluatePredicateCost) { |
| // Create the index on all the attributes. |
| createIndex({0, 1, 2, 3, 4, 5}, kIndexSubBlockSize); |
| const int min = 250, max = 500; |
| for (std::size_t i = min; i <= max; ++i) { |
| if (i % 10 == 0) { |
| generateAndInsertTuple(i, true, "suffix"); |
| } else { |
| generateAndInsertTuple(i, false, "suffix"); |
| } |
| } |
| index_->rebuild(); |
| |
| // Test with inline values, returning both possible value types. |
| std::unique_ptr<ComparisonPredicate> predicate( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, min)); |
| predicate_cost_t eval_cost = index_->estimatePredicateEvaluationCost(*predicate); |
| EXPECT_EQ(predicate_cost::kConstantTime, eval_cost); |
| |
| predicate.reset( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, max + 1)); |
| eval_cost = index_->estimatePredicateEvaluationCost(*predicate); |
| EXPECT_EQ(predicate_cost::kConstantTime, eval_cost); |
| |
| predicate.reset( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, ((max - min)/2) + min)); |
| eval_cost = index_->estimatePredicateEvaluationCost(*predicate); |
| EXPECT_EQ(predicate_cost::kInfinite, eval_cost); |
| |
| // Test with out of line values. |
| predicate.reset( |
| generateStringComparisonPredicate(ComparisonID::kLess, 5, " ")); |
| eval_cost = index_->estimatePredicateEvaluationCost(*predicate); |
| EXPECT_EQ(predicate_cost::kConstantTime, eval_cost); |
| |
| predicate.reset( |
| generateStringComparisonPredicate(ComparisonID::kGreater, 5, " ")); |
| eval_cost = index_->estimatePredicateEvaluationCost(*predicate); |
| EXPECT_EQ(predicate_cost::kConstantTime, eval_cost); |
| |
| predicate.reset( |
| generateStringComparisonPredicate(ComparisonID::kEqual, 5, "300suffix")); |
| eval_cost = index_->estimatePredicateEvaluationCost(*predicate); |
| EXPECT_EQ(predicate_cost::kInfinite, eval_cost); |
| |
| // Test with an inconsistent index. |
| tuple_id new_tuple = generateAndInsertTuple(0x1337, false, "suffix"); |
| predicate.reset(generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, min)); |
| EXPECT_TRUE(index_->addEntry(new_tuple)); |
| EXPECT_FALSE(requiresRebuild()); |
| |
| // Inconsistent indices should have a high evaluation cost. |
| EXPECT_EQ(predicate_cost::kConstantTime, index_->estimatePredicateEvaluationCost(*predicate)); |
| } |
| |
| TEST_F(SMAIndexSubBlockTest, TestGetMatchesForPredicate) { |
| // Create the index on all the attributes. |
| createIndex({0, 1, 2, 3, 4, 5}, kIndexSubBlockSize); |
| const int min = 250, max = 500; |
| for (std::size_t i = min; i <= max; ++i) { |
| if (i % 10 == 0) { |
| generateAndInsertTuple(i, true, "suffix"); |
| } else { |
| generateAndInsertTuple(i, false, "suffix"); |
| } |
| } |
| index_->rebuild(); |
| |
| // Test with inline values. |
| // Check that no tuples have been returned. |
| std::unique_ptr<ComparisonPredicate> predicate( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, min)); |
| std::unique_ptr<TupleIdSequence> result(index_->getMatchesForPredicate(*predicate, nullptr)); |
| EXPECT_EQ(static_cast<std::size_t>(tuple_store_->getMaxTupleID() + 1), result->length()); |
| EXPECT_EQ(static_cast<std::size_t>(0), result->numTuples()); |
| |
| // Check that all tuples have been returned. |
| predicate.reset( |
| generateNumericComparisonPredicate<LongType>(ComparisonID::kLess, 0, max + 1)); |
| result.reset(index_->getMatchesForPredicate(*predicate, nullptr)); |
| EXPECT_EQ(static_cast<std::size_t>(tuple_store_->getMaxTupleID() + 1), result->length()); |
| EXPECT_EQ(static_cast<std::size_t>(tuple_store_->getMaxTupleID() + 1), result->numTuples()); |
| } |
| |
| } // namespace quickstep |
