QUICKSTEP-18: Allow BasicColumnStoreTupleStorageSubBlock to be unsorted Review comments applied
Revert build fix for Lexer (separate PR has been opened) Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/c1476d1e Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/c1476d1e Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/c1476d1e Branch: refs/heads/adaptive-bloom-filters Commit: c1476d1e7637a943b00e104cdfd9498e3c7cfe03 Parents: 00ca1e4 Author: Craig Chasseur <spoonbo...@gmail.com> Authored: Sun Jun 12 04:01:17 2016 -0700 Committer: Craig Chasseur <spoonbo...@gmail.com> Committed: Sun Jun 19 21:58:27 2016 -0700 ---------------------------------------------------------------------- parser/CMakeLists.txt | 7 +- .../BasicColumnStoreTupleStorageSubBlock.cpp | 68 +++++---- .../BasicColumnStoreTupleStorageSubBlock.hpp | 15 +- storage/StorageBlockLayout.proto | 6 +- ...ColumnStoreTupleStorageSubBlock_unittest.cpp | 137 ++++++++++++++----- 5 files changed, 158 insertions(+), 75 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c1476d1e/parser/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/parser/CMakeLists.txt b/parser/CMakeLists.txt index 55c4a67..114ad14 100644 --- a/parser/CMakeLists.txt +++ b/parser/CMakeLists.txt @@ -384,15 +384,12 @@ set_property(SOURCE ${CMAKE_CURRENT_BINARY_DIR}/SqlParser_gen.cpp APPEND PROPERT include(CheckCXXCompilerFlag) CHECK_CXX_COMPILER_FLAG("-Wno-deprecated-register" COMPILER_HAS_WNO_DEPRECATED_REGISTER) if (COMPILER_HAS_WNO_DEPRECATED_REGISTER) - set_property(TARGET quickstep_parser_SqlLexer APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-deprecated-register") + set_target_properties(quickstep_parser_SqlLexer PROPERTIES COMPILE_FLAGS "-Wno-deprecated-register") endif() # GCC will make a warning for unsigned-signed comparisons which are inherent # in the lexer. For this, we turn off the sign compare. -CHECK_CXX_COMPILER_FLAG("-Wno-sign-compare" COMPILER_HAS_WNO_SIGN_COMPARE) -if (COMPILER_HAS_WNO_SIGN_COMPARE) - set_property(TARGET quickstep_parser_SqlLexer APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-sign-compare") -endif() +set_target_properties(quickstep_parser_SqlLexer PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") add_subdirectory(tests) http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c1476d1e/storage/BasicColumnStoreTupleStorageSubBlock.cpp ---------------------------------------------------------------------- diff --git a/storage/BasicColumnStoreTupleStorageSubBlock.cpp b/storage/BasicColumnStoreTupleStorageSubBlock.cpp index 0c913ff..a474437 100644 --- a/storage/BasicColumnStoreTupleStorageSubBlock.cpp +++ b/storage/BasicColumnStoreTupleStorageSubBlock.cpp @@ -52,6 +52,8 @@ #include "utility/PtrVector.hpp" #include "utility/ScopedBuffer.hpp" +#include "glog/logging.h" + using std::memcpy; using std::memmove; using std::size_t; @@ -104,14 +106,19 @@ BasicColumnStoreTupleStorageSubBlock::BasicColumnStoreTupleStorageSubBlock( new_block, sub_block_memory, sub_block_memory_size), + sort_specified_(description_.HasExtension( + BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id)), sorted_(true), header_(static_cast<BasicColumnStoreHeader*>(sub_block_memory)) { if (!DescriptionIsValid(relation_, description_)) { FATAL_ERROR("Attempted to construct a BasicColumnStoreTupleStorageSubBlock from an invalid description."); } - sort_column_id_ = description_.GetExtension(BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id); - sort_column_type_ = &(relation_.getAttributeById(sort_column_id_)->getType()); + if (sort_specified_) { + sort_column_id_ = description_.GetExtension( + BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id); + sort_column_type_ = &(relation_.getAttributeById(sort_column_id_)->getType()); + } if (sub_block_memory_size < sizeof(BasicColumnStoreHeader)) { throw BlockMemoryTooSmall("BasicColumnStoreTupleStorageSubBlock", sub_block_memory_size_); @@ -183,26 +190,27 @@ bool BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid( if (description.sub_block_type() != TupleStorageSubBlockDescription::BASIC_COLUMN_STORE) { return false; } - // Make sure a sort_attribute_id is specified. - if (!description.HasExtension(BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id)) { - return false; - } // Make sure relation is not variable-length. if (relation.isVariableLength()) { return false; } - // Check that the specified sort attribute exists and can be ordered by LessComparison. - attribute_id sort_attribute_id = description.GetExtension( - BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id); - if (!relation.hasAttributeWithId(sort_attribute_id)) { - return false; - } - const Type &sort_attribute_type = relation.getAttributeById(sort_attribute_id)->getType(); - if (!ComparisonFactory::GetComparison(ComparisonID::kLess).canCompareTypes(sort_attribute_type, - sort_attribute_type)) { - return false; + // If a sort attribute is specified, check that it exists and can be ordered + // by LessComparison. + if (description.HasExtension( + BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id)) { + const attribute_id sort_attribute_id = description.GetExtension( + BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id); + if (!relation.hasAttributeWithId(sort_attribute_id)) { + return false; + } + const Type &sort_attribute_type = + relation.getAttributeById(sort_attribute_id)->getType(); + if (!ComparisonFactory::GetComparison(ComparisonID::kLess).canCompareTypes( + sort_attribute_type, sort_attribute_type)) { + return false; + } } return true; @@ -230,9 +238,9 @@ TupleStorageSubBlock::InsertResult BasicColumnStoreTupleStorageSubBlock::insertT } tuple_id insert_position = header_->num_tuples; - // If sort column is NULL, skip the search and put the new tuple at the end - // of everything else. - if (!tuple.getAttributeValue(sort_column_id_).isNull()) { + // If this column store is unsorted, or the value of the sort column is NULL, + // skip the search and put the new tuple at the end of everything else. + if (sort_specified_ && !tuple.getAttributeValue(sort_column_id_).isNull()) { // Binary search for the appropriate insert location. ColumnStripeIterator begin_it(column_stripes_[sort_column_id_], relation_.getAttributeById(sort_column_id_)->getType().maximumByteLength(), @@ -435,6 +443,9 @@ bool BasicColumnStoreTupleStorageSubBlock::canSetAttributeValuesInPlaceTyped( const tuple_id tuple, const std::unordered_map<attribute_id, TypedValue> &new_values) const { DEBUG_ASSERT(hasTupleWithID(tuple)); + if (!sort_specified_) { + return true; + } for (std::unordered_map<attribute_id, TypedValue>::const_iterator it = new_values.begin(); it != new_values.end(); @@ -453,7 +464,7 @@ void BasicColumnStoreTupleStorageSubBlock::setAttributeValueInPlaceTyped( const tuple_id tuple, const attribute_id attr, const TypedValue &value) { - DEBUG_ASSERT(attr != sort_column_id_); + DCHECK(!sort_specified_ || (attr != sort_column_id_)); const Type &attr_type = relation_.getAttributeById(attr)->getType(); void *value_position = static_cast<char*>(column_stripes_[attr]) @@ -473,10 +484,10 @@ void BasicColumnStoreTupleStorageSubBlock::setAttributeValueInPlaceTyped( bool BasicColumnStoreTupleStorageSubBlock::deleteTuple(const tuple_id tuple) { DEBUG_ASSERT(hasTupleWithID(tuple)); - if (!column_null_bitmaps_.elementIsNull(sort_column_id_)) { - if (column_null_bitmaps_[sort_column_id_].getBit(tuple)) { - --(header_->nulls_in_sort_column); - } + if (sort_specified_ + && !column_null_bitmaps_.elementIsNull(sort_column_id_) + && column_null_bitmaps_[sort_column_id_].getBit(tuple)) { + --(header_->nulls_in_sort_column); } if (tuple == header_->num_tuples - 1) { @@ -563,7 +574,7 @@ bool BasicColumnStoreTupleStorageSubBlock::bulkDeleteTuples(TupleIdSequence *tup predicate_cost_t BasicColumnStoreTupleStorageSubBlock::estimatePredicateEvaluationCost( const ComparisonPredicate &predicate) const { - if (predicate.isAttributeLiteralComparisonPredicate()) { + if (sort_specified_ && predicate.isAttributeLiteralComparisonPredicate()) { std::pair<bool, attribute_id> comparison_attr = predicate.getAttributeFromAttributeLiteralComparison(); if (comparison_attr.second == sort_column_id_) { return predicate_cost::kBinarySearch; @@ -575,6 +586,11 @@ predicate_cost_t BasicColumnStoreTupleStorageSubBlock::estimatePredicateEvaluati TupleIdSequence* BasicColumnStoreTupleStorageSubBlock::getMatchesForPredicate( const ComparisonPredicate &predicate, const TupleIdSequence *filter) const { + DCHECK(sort_specified_) << + "Called BasicColumnStoreTupleStorageSubBlock::getMatchesForPredicate() " + "for an unsorted column store (predicate should have been evaluated " + "with a scan instead)."; + TupleIdSequence *matches = SortColumnPredicateEvaluator::EvaluatePredicateForUncompressedSortColumn( predicate, relation_, @@ -671,6 +687,8 @@ void BasicColumnStoreTupleStorageSubBlock::shiftNullBitmaps( // total size of tuples contained in this sub-block. It could be done with // less memory, although the implementation would be more complex. bool BasicColumnStoreTupleStorageSubBlock::rebuildInternal() { + DCHECK(sort_specified_); + const tuple_id num_tuples = header_->num_tuples; // Immediately return if 1 or 0 tuples. if (num_tuples <= 1) { http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c1476d1e/storage/BasicColumnStoreTupleStorageSubBlock.hpp ---------------------------------------------------------------------- diff --git a/storage/BasicColumnStoreTupleStorageSubBlock.hpp b/storage/BasicColumnStoreTupleStorageSubBlock.hpp index 6c72c78..b36eb20 100644 --- a/storage/BasicColumnStoreTupleStorageSubBlock.hpp +++ b/storage/BasicColumnStoreTupleStorageSubBlock.hpp @@ -108,7 +108,9 @@ class BasicColumnStoreTupleStorageSubBlock : public TupleStorageSubBlock { } bool adHocInsertIsEfficient() const override { - return false; + // Ad-hoc insert is only efficient if it doesn't require resorting the + // whole block. + return !sort_specified_; } TupleStorageSubBlockType getTupleStorageSubBlockType() const override { @@ -170,14 +172,14 @@ class BasicColumnStoreTupleStorageSubBlock : public TupleStorageSubBlock { const TupleIdSequence *filter) const override; void rebuild() override { - if (!sorted_) { + if (sort_specified_ && !sorted_) { rebuildInternal(); } } bool isInsertOrderPreserving() const override { - // Rebuild reorders inserts based on sort column. - return false; + // Rebuild reorders inserts based on sort column if any is specified. + return !sort_specified_; } private: @@ -211,11 +213,12 @@ class BasicColumnStoreTupleStorageSubBlock : public TupleStorageSubBlock { const tuple_id distance); // Sort all columns according to ascending order of values in the sort - // column. Returns true if any reordering occured. + // column. Returns true if any reordering occured. This should only be called + // when 'sort_specified_' is true, otherwise the block is always "built". bool rebuildInternal(); tuple_id max_tuples_; - bool sorted_; + bool sort_specified_, sorted_; attribute_id sort_column_id_; const Type *sort_column_type_; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c1476d1e/storage/StorageBlockLayout.proto ---------------------------------------------------------------------- diff --git a/storage/StorageBlockLayout.proto b/storage/StorageBlockLayout.proto index 9e13fbe..cafc0e9 100644 --- a/storage/StorageBlockLayout.proto +++ b/storage/StorageBlockLayout.proto @@ -1,7 +1,7 @@ // Copyright 2011-2015 Quickstep Technologies LLC. // Copyright 2015-2016 Pivotal Software, Inc. // Copyright 2016, Quickstep Research Group, Computer Sciences Department, -// University of WisconsinâMadison. +// University of Wisconsin-Madison. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -38,8 +38,8 @@ message TupleStorageSubBlockDescription { message BasicColumnStoreTupleStorageSubBlockDescription { extend TupleStorageSubBlockDescription { - // Extentions may not be marked required in protobuf 2.6 or higher. This - // field is considered required when sub_block_type == BASIC_COLUMN_STORE. + // Indicates the attribute to sort the column store by. If unset, the + // column store will be unsorted. optional int32 sort_attribute_id = 64; } } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/c1476d1e/storage/tests/BasicColumnStoreTupleStorageSubBlock_unittest.cpp ---------------------------------------------------------------------- diff --git a/storage/tests/BasicColumnStoreTupleStorageSubBlock_unittest.cpp b/storage/tests/BasicColumnStoreTupleStorageSubBlock_unittest.cpp index e5476f7..df8b479 100644 --- a/storage/tests/BasicColumnStoreTupleStorageSubBlock_unittest.cpp +++ b/storage/tests/BasicColumnStoreTupleStorageSubBlock_unittest.cpp @@ -109,8 +109,11 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam tuple_store_description_.reset(new TupleStorageSubBlockDescription()); tuple_store_description_->set_sub_block_type(TupleStorageSubBlockDescription::BASIC_COLUMN_STORE); - tuple_store_description_->SetExtension(BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id, - sort_column); + if (sort_column != kInvalidCatalogId) { + tuple_store_description_->SetExtension( + BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id, + sort_column); + } tuple_store_.reset(new BasicColumnStoreTupleStorageSubBlock(*relation_, *tuple_store_description_, @@ -197,7 +200,7 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam } int computeNullsInSortColumn(const attribute_id sort_column_id) { - if (!GetParam()) { + if (sort_column_id == kInvalidCatalogId || !GetParam()) { return 0; } @@ -341,11 +344,15 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam EXPECT_EQ(computeRowCapacity() - regular_tuples_deleted - last_tuples_deleted, static_cast<std::size_t>(tuple_store_->getMaxTupleID() + 1)); - const Type &sort_attribute_type = relation_->getAttributeById(sort_attribute_id)->getType(); - std::unique_ptr<UncheckedComparator> sort_attribute_comparator( - ComparisonFactory::GetComparison(ComparisonID::kLessOrEqual).makeUncheckedComparatorForTypes( - sort_attribute_type, - sort_attribute_type)); + std::unique_ptr<UncheckedComparator> sort_attribute_comparator; + if (sort_attribute_id != kInvalidCatalogId) { + const Type &sort_attribute_type = + relation_->getAttributeById(sort_attribute_id)->getType(); + sort_attribute_comparator.reset( + ComparisonFactory::GetComparison(ComparisonID::kLessOrEqual) + .makeUncheckedComparatorForTypes(sort_attribute_type, + sort_attribute_type)); + } std::vector<bool> existence_check_vector; existence_check_vector.resize(computeRowCapacity() - 2, false); @@ -390,17 +397,21 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam } } - // Check ordering. - TypedValue sort_attribute_value = tuple_store_->getAttributeValueTyped(tid, sort_attribute_id); - if (previous_sort_attribute_value.get() != nullptr) { - if (previous_sort_attribute_value->isNull()) { - EXPECT_TRUE(sort_attribute_value.isNull()); - } else if (!sort_attribute_value.isNull()) { - EXPECT_TRUE(sort_attribute_comparator->compareTypedValues(*previous_sort_attribute_value, - sort_attribute_value)); + // Check ordering if block is sorted. + if (sort_attribute_id != kInvalidCatalogId) { + TypedValue sort_attribute_value = + tuple_store_->getAttributeValueTyped(tid, sort_attribute_id); + if (previous_sort_attribute_value) { + if (previous_sort_attribute_value->isNull()) { + EXPECT_TRUE(sort_attribute_value.isNull()); + } else if (!sort_attribute_value.isNull()) { + EXPECT_TRUE(sort_attribute_comparator->compareTypedValues( + *previous_sort_attribute_value, + sort_attribute_value)); + } } + previous_sort_attribute_value.reset(new TypedValue(sort_attribute_value)); } - previous_sort_attribute_value.reset(new TypedValue(sort_attribute_value)); } EXPECT_EQ(2 - last_tuples_deleted, num_last_tuples); @@ -435,13 +446,18 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam delete_sequence.set(tid, true); } // One of the special "last" values. - if (GetParam()) { + if (sort_attribute_id != kInvalidCatalogId && GetParam()) { delete_sequence.set(row_capacity - computeNullsInSortColumn(sort_attribute_id) - 2, true); } EXPECT_TRUE(tuple_store_->bulkDeleteTuples(&delete_sequence)); - checkBlockValues(sort_attribute_id, delete_sequence.numTuples() + 2 - 1, 1); + if (sort_attribute_id == kInvalidCatalogId) { + // There is no special treatment of "last" values without sorting. + checkBlockValues(sort_attribute_id, delete_sequence.numTuples(), 2); + } else { + checkBlockValues(sort_attribute_id, delete_sequence.numTuples() + 2 - 1, 1); + } } // Create a ComparisonPredicate of the form "attribute comp literal". @@ -702,23 +718,26 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam TypedValue new_wide_char_value(kChar, new_wide_char_lit, 32); std::unordered_map<attribute_id, TypedValue> proposed_values; - switch (sort_attribute_id) { - case 0: - proposed_values.emplace(0, new_int_value); - break; - case 1: - proposed_values.emplace(1, new_double_value); - break; - case 2: - proposed_values.emplace(2, new_narrow_char_value); - break; - case 3: - proposed_values.emplace(3, new_wide_char_value); - break; - } + if (sort_attribute_id != kInvalidCatalogId) { + switch (sort_attribute_id) { + case 0: + proposed_values.emplace(0, new_int_value); + break; + case 1: + proposed_values.emplace(1, new_double_value); + break; + case 2: + proposed_values.emplace(2, new_narrow_char_value); + break; + case 3: + proposed_values.emplace(3, new_wide_char_value); + break; + } - // Can't overwrite a sort column value in-place. - EXPECT_FALSE(tuple_store_->canSetAttributeValuesInPlaceTyped(target_tid, proposed_values)); + // Can't overwrite a sort column value in-place. + EXPECT_FALSE(tuple_store_->canSetAttributeValuesInPlaceTyped( + target_tid, proposed_values)); + } // Other column values should be OK. proposed_values.clear(); @@ -726,7 +745,9 @@ class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam proposed_values.emplace(1, new_double_value); proposed_values.emplace(2, new_narrow_char_value); proposed_values.emplace(3, new_wide_char_value); - proposed_values.erase(sort_attribute_id); + if (sort_attribute_id != kInvalidCatalogId) { + proposed_values.erase(sort_attribute_id); + } EXPECT_TRUE(tuple_store_->canSetAttributeValuesInPlaceTyped(target_tid, proposed_values)); // Actually set values. @@ -820,6 +841,14 @@ TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DescriptionIsValidTest) { *tuple_store_description_)); } + // Also check a description that doesn't specify a sort column. + tuple_store_description_.reset(new TupleStorageSubBlockDescription()); + tuple_store_description_->set_sub_block_type( + TupleStorageSubBlockDescription::BASIC_COLUMN_STORE); + EXPECT_TRUE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid( + *relation_, + *tuple_store_description_)); + // An uninitialized description is not valid. tuple_store_description_.reset(new TupleStorageSubBlockDescription()); EXPECT_FALSE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid( @@ -859,6 +888,24 @@ TEST_P(BasicColumnStoreTupleStorageSubBlockTest, BlockTooSmallTest) { EXPECT_THROW(createBlock(0, 32), BlockMemoryTooSmall); } +TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithNoSortColumnTest) { + // Non-random, batch insert. + createBlock(kInvalidCatalogId, kSubBlockSize); + fillBlockWithSampleData(false, false); + + // Non-random, ad-hoc insert. + createBlock(kInvalidCatalogId, kSubBlockSize); + fillBlockWithSampleData(false, true); + + // Random order, batch insert. + createBlock(kInvalidCatalogId, kSubBlockSize); + fillBlockWithSampleData(true, false); + + // Random order, ad-hoc insert. + createBlock(kInvalidCatalogId, kSubBlockSize); + fillBlockWithSampleData(true, true); +} + TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithIntSortColumnTest) { // Non-random, batch insert. createBlock(0, kSubBlockSize); @@ -931,6 +978,12 @@ TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithWideCharSortColumnTes fillBlockWithSampleData(true, true); } +TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithNoSortColumnTest) { + createBlock(kInvalidCatalogId, kSubBlockSize); + fillBlockWithSampleData(true, false); + checkBlockValues(kInvalidCatalogId, 0, 0); +} + TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithIntSortColumnTest) { createBlock(0, kSubBlockSize); fillBlockWithSampleData(true, false); @@ -955,6 +1008,10 @@ TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithWideCharSortColumn checkBlockValues(3, 0, 0); } +TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithNoSortColumnTest) { + runDeleteTest(kInvalidCatalogId); +} + TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithIntSortColumnTest) { runDeleteTest(0); } @@ -971,6 +1028,10 @@ TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithWideCharSortColumnTes runDeleteTest(3); } +TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithNoSortColumnTest) { + runCheckPredicateTest(kInvalidCatalogId); +} + TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithIntSortColumnTest) { runCheckPredicateTest(0); } @@ -987,6 +1048,10 @@ TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithWideC runCheckPredicateTest(3); } +TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithNoSortColumnTest) { + runSetAttributeValueInPlaceTypedTest(kInvalidCatalogId); +} + TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithIntSortColumnTest) { runSetAttributeValueInPlaceTypedTest(0); }