TupleIdSequence* CompressedColumnStoreTupleStorageSubBlock::getNotEqualCodes(
const attribute_id attr_id,
const std::uint32_t code,
const TupleIdSequence *filter) const {
if (attr_id == sort_column_id_) {
// Special (fast) case: do a binary search of the sort column.
pair<uint32_t, uint32_t> code_range(code, code + 1);
// Adjust the upper limit if doing so can avoid an extra binary search.
if (dictionary_coded_attributes_[attr_id]) {
if (code_range.second == compressedGetDictionary(attr_id).numberOfCodes()) {
code_range.second = numeric_limits<uint32_t>::max();
}
} else if (code_range.first == GetMaxTruncatedValue(compression_info_.attribute_size(attr_id))) {
code_range.second = numeric_limits<uint32_t>::max();
}
pair<tuple_id, tuple_id> tuple_range = getCompressedSortColumnRange(code_range);
// We searched for the range of equal codes, so return its complement.
TupleIdSequence *matches = new TupleIdSequence(*static_cast<const tuple_id*>(sub_block_memory_));
matches->setRange(0, tuple_range.first, true);
matches->setRange(tuple_range.second,
*static_cast<const tuple_id*>(sub_block_memory_) - tuple_range.second,
true);
if (filter != nullptr) {
matches->intersectWith(*filter);
}
return matches;
} else {
return getCodesSatisfyingComparison<not_equal_to>(attr_id, code, filter);
}
}
TupleIdSequence* CompressedColumnStoreTupleStorageSubBlock::getGreaterOrEqualCodes(
const attribute_id attr_id,
const std::uint32_t code,
const TupleIdSequence *filter) const {
if (attr_id == sort_column_id_) {
// Special (fast) case: do a binary search of the sort column.
TupleIdSequence *matches = new TupleIdSequence(*static_cast<const tuple_id*>(sub_block_memory_));
pair<tuple_id, tuple_id> tuple_range
= getCompressedSortColumnRange(pair<uint32_t, uint32_t>(code, numeric_limits<uint32_t>::max()));
matches->setRange(tuple_range.first, tuple_range.second - tuple_range.first, true);
if (filter != nullptr) {
matches->intersectWith(*filter);
}
return matches;
} else {
return getCodesSatisfyingComparison<less_equal>(attr_id, code, filter);
}
}
TupleIdSequence* CompressedColumnStoreTupleStorageSubBlock::getCodesInRange(
const attribute_id attr_id,
const std::pair<std::uint32_t, std::uint32_t> range,
const TupleIdSequence *filter) const {
#ifdef QUICKSTEP_ENABLE_VECTOR_PREDICATE_SHORT_CIRCUIT
static constexpr bool short_circuit = true;
#else
static constexpr bool short_circuit = false;
#endif
TupleIdSequence *matches = new TupleIdSequence(*static_cast<const tuple_id*>(sub_block_memory_));
if (attr_id == sort_column_id_) {
// Special (fast) case: do a binary search of the sort column.
pair<tuple_id, tuple_id> tuple_range = getCompressedSortColumnRange(range);
matches->setRange(tuple_range.first, tuple_range.second - tuple_range.first, true);
if (filter != nullptr) {
matches->intersectWith(*filter);
}
} else {
const void *attr_stripe = column_stripes_[attr_id];
if (!short_circuit || (filter == nullptr)) {
switch (compression_info_.attribute_size(attr_id)) {
case 1:
for (tuple_id tid = 0;
tid < *static_cast<const tuple_id*>(sub_block_memory_);
++tid) {
if (range.first <= (static_cast<const uint8_t*>(attr_stripe)[tid])
&& (static_cast<const uint8_t*>(attr_stripe)[tid] < range.second)) {
matches->set(tid);
}
}
break;
case 2:
for (tuple_id tid = 0;
tid < *static_cast<const tuple_id*>(sub_block_memory_);
++tid) {
if (range.first <= (static_cast<const uint16_t*>(attr_stripe)[tid])
&& (static_cast<const uint16_t*>(attr_stripe)[tid] < range.second)) {
matches->set(tid);
}
}
break;
case 4:
for (tuple_id tid = 0;
tid < *static_cast<const tuple_id*>(sub_block_memory_);
++tid) {
if (range.first <= (static_cast<const uint32_t*>(attr_stripe)[tid])
&& (static_cast<const uint32_t*>(attr_stripe)[tid] < range.second)) {
matches->set(tid);
}
}
break;
default:
FATAL_ERROR("Unexpected byte-length (not 1, 2, or 4) for compressed "
"attribute ID " << attr_id
<< " in CompressedColumnStoreTupleStorageSubBlock::getCodesInRange()");
}
if (filter != nullptr) {
matches->intersectWith(*filter);
}
} else {
switch (compression_info_.attribute_size(attr_id)) {
case 1:
for (TupleIdSequence::const_iterator filter_it = filter->begin();
filter_it != filter->end();
++filter_it) {
if (range.first <= (static_cast<const uint8_t*>(attr_stripe)[*filter_it])
&& (static_cast<const uint8_t*>(attr_stripe)[*filter_it] < range.second)) {
matches->set(*filter_it);
}
}
break;
case 2:
for (TupleIdSequence::const_iterator filter_it = filter->begin();
filter_it != filter->end();
++filter_it) {
if (range.first <= (static_cast<const uint16_t*>(attr_stripe)[*filter_it])
&& (static_cast<const uint16_t*>(attr_stripe)[*filter_it] < range.second)) {
matches->set(*filter_it);
}
}
break;
case 4:
for (TupleIdSequence::const_iterator filter_it = filter->begin();
filter_it != filter->end();
++filter_it) {
if (range.first <= (static_cast<const uint32_t*>(attr_stripe)[*filter_it])
&& (static_cast<const uint32_t*>(attr_stripe)[*filter_it] < range.second)) {
matches->set(*filter_it);
}
}
break;
default:
FATAL_ERROR("Unexpected byte-length (not 1, 2, or 4) for compressed "
"attribute ID " << attr_id
<< " in CompressedColumnStoreTupleStorageSubBlock::getCodesInRange()");
}
}
}
return matches;
}
TupleIdSequence* CompressedColumnStoreTupleStorageSubBlock::getNotEqualCodesExcludingNull(
const attribute_id attr_id,
const std::uint32_t code,
const std::uint32_t null_code,
const TupleIdSequence *filter) const {
#ifdef QUICKSTEP_ENABLE_VECTOR_PREDICATE_SHORT_CIRCUIT
static constexpr bool short_circuit = true;
#else
static constexpr bool short_circuit = false;
#endif
if (attr_id == sort_column_id_) {
// Special (fast) case: do a binary search of the sort column.
pair<uint32_t, uint32_t> code_range(code, code + 1);
// Adjust the upper limit if doing so can avoid an extra binary search.
if (dictionary_coded_attributes_[attr_id]) {
if (code_range.second == compressedGetDictionary(attr_id).numberOfCodes()) {
code_range.second = numeric_limits<uint32_t>::max();
}
} else if (code_range.first == GetMaxTruncatedValue(compression_info_.attribute_size(attr_id))) {
code_range.second = numeric_limits<uint32_t>::max();
}
pair<tuple_id, tuple_id> tuple_range = getCompressedSortColumnRange(code_range);
// Search for the beginning of nulls in the sort column.
pair<uint32_t, uint32_t> null_range(null_code, numeric_limits<uint32_t>::max());
pair<tuple_id, tuple_id> limit_range = getCompressedSortColumnRange(null_range);
// We searched for the range of equal codes, so return its complement.
TupleIdSequence *matches = new TupleIdSequence(*static_cast<const tuple_id*>(sub_block_memory_));
matches->setRange(0, tuple_range.first, true);
matches->setRange(tuple_range.second, limit_range.first - tuple_range.second, true);
if (filter != nullptr) {
matches->intersectWith(*filter);
}
return matches;
} else {
TupleIdSequence *matches = new TupleIdSequence(*static_cast<const tuple_id*>(sub_block_memory_));
const void *attr_stripe = column_stripes_[attr_id];
if (!short_circuit || (filter == nullptr)) {
switch (compression_info_.attribute_size(attr_id)) {
case 1:
for (tuple_id tid = 0;
tid < *static_cast<const tuple_id*>(sub_block_memory_);
++tid) {
if ((code != static_cast<const uint8_t*>(attr_stripe)[tid])
&& (null_code != static_cast<const uint8_t*>(attr_stripe)[tid])) {
matches->set(tid);
}
}
break;
case 2:
for (tuple_id tid = 0;
tid < *static_cast<const tuple_id*>(sub_block_memory_);
++tid) {
if ((code != static_cast<const uint16_t*>(attr_stripe)[tid])
&& (null_code != static_cast<const uint16_t*>(attr_stripe)[tid])) {
matches->set(tid);
}
}
break;
case 4:
for (tuple_id tid = 0;
tid <= *static_cast<const tuple_id*>(sub_block_memory_);
++tid) {
if ((code != static_cast<const uint16_t*>(attr_stripe)[tid])
&& (null_code != static_cast<const uint16_t*>(attr_stripe)[tid])) {
matches->set(tid);
}
}
break;
default:
FATAL_ERROR("Unexpected byte-length (not 1, 2, or 4) for compressed "
"attribute ID " << attr_id
<< " in CompressedColumnStoreTupleStorageSubBlock::getNotEqualCodesExcludingNull()");
}
if (filter != nullptr) {
matches->intersectWith(*filter);
}
} else {
switch (compression_info_.attribute_size(attr_id)) {
case 1:
for (TupleIdSequence::const_iterator filter_it = filter->begin();
filter_it != filter->end();
++filter_it) {
if ((code != static_cast<const uint8_t*>(attr_stripe)[*filter_it])
&& (null_code != static_cast<const uint8_t*>(attr_stripe)[*filter_it])) {
matches->set(*filter_it);
}
}
break;
case 2:
for (TupleIdSequence::const_iterator filter_it = filter->begin();
filter_it != filter->end();
++filter_it) {
if ((code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])
&& (null_code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])) {
matches->set(*filter_it);
}
}
break;
case 4:
for (TupleIdSequence::const_iterator filter_it = filter->begin();
filter_it != filter->end();
++filter_it) {
if ((code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])
&& (null_code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])) {
matches->set(*filter_it);
}
}
break;
default:
FATAL_ERROR("Unexpected byte-length (not 1, 2, or 4) for compressed "
"attribute ID " << attr_id
<< " in CompressedColumnStoreTupleStorageSubBlock::getNotEqualCodesExcludingNull()");
}
}
return matches;
}
}
