This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 06d0035c02 [refactor](non-vec)remove schema change related non-vec
code (#15313)
06d0035c02 is described below
commit 06d0035c0295902dd068aeb7aebe065d9f5a2719
Author: yiguolei <[email protected]>
AuthorDate: Fri Dec 23 18:33:04 2022 +0800
[refactor](non-vec)remove schema change related non-vec code (#15313)
Co-authored-by: yiguolei <[email protected]>
---
be/src/olap/memtable.cpp | 3 +-
be/src/olap/row_block.h | 4 -
be/src/olap/rowset/beta_rowset_reader.cpp | 1 -
be/src/olap/rowset/beta_rowset_reader.h | 3 -
be/src/olap/schema_change.cpp | 824 ------------------
be/src/olap/schema_change.h | 29 -
be/src/util/tuple_row_zorder_compare.cpp | 204 -----
be/src/util/tuple_row_zorder_compare.h | 29 -
be/test/CMakeLists.txt | 1 -
be/test/util/tuple_row_zorder_compare_test.cpp | 1111 ------------------------
10 files changed, 1 insertion(+), 2208 deletions(-)
diff --git a/be/src/olap/memtable.cpp b/be/src/olap/memtable.cpp
index 63575a3bb2..fda31df925 100644
--- a/be/src/olap/memtable.cpp
+++ b/be/src/olap/memtable.cpp
@@ -86,8 +86,7 @@ MemTable::MemTable(TabletSharedPtr tablet, Schema* schema,
const TabletSchema* t
_aggregate_two_row_fn = &MemTable::_aggregate_two_row;
}
if (tablet_schema->sort_type() == SortType::ZORDER) {
- _row_comparator = std::make_shared<TupleRowZOrderComparator>(
- _schema, tablet_schema->sort_col_num());
+ LOG(FATAL) << "ZOrder not supported";
} else {
_row_comparator = std::make_shared<RowCursorComparator>(_schema);
}
diff --git a/be/src/olap/row_block.h b/be/src/olap/row_block.h
index 0d9ed4c24a..eead5cb9cf 100644
--- a/be/src/olap/row_block.h
+++ b/be/src/olap/row_block.h
@@ -49,10 +49,6 @@ struct RowBlockInfo {
// 3. 给定查询的key，在RowBlock内做二分查找，返回起点的行偏移；
// 4. 向量化的条件过滤下推到RowBlock级别进行，因此增加完成过滤的数据读取接口
class RowBlock {
- // Please keep these classes as 'friend'. They have to use lots of
private fields for
- // faster operation.
- friend class RowBlockChanger;
-
public:
RowBlock(TabletSchemaSPtr schema);
diff --git a/be/src/olap/rowset/beta_rowset_reader.cpp
b/be/src/olap/rowset/beta_rowset_reader.cpp
index e5d461210e..1c9cf8c449 100644
--- a/be/src/olap/rowset/beta_rowset_reader.cpp
+++ b/be/src/olap/rowset/beta_rowset_reader.cpp
@@ -215,7 +215,6 @@ Status BetaRowsetReader::init(RowsetReaderContext*
read_context) {
return Status::Error<ROWSET_READER_INIT>();
}
_iterator.reset(final_iterator);
-
return Status::OK();
}
diff --git a/be/src/olap/rowset/beta_rowset_reader.h
b/be/src/olap/rowset/beta_rowset_reader.h
index c80d258d3b..2812339b10 100644
--- a/be/src/olap/rowset/beta_rowset_reader.h
+++ b/be/src/olap/rowset/beta_rowset_reader.h
@@ -85,9 +85,6 @@ private:
std::unique_ptr<RowwiseIterator> _iterator;
- std::shared_ptr<RowBlockV2> _input_block;
- std::unique_ptr<RowCursor> _row;
-
// make sure this handle is initialized and valid before
// reading data.
SegmentCacheHandle _segment_cache_handle;
diff --git a/be/src/olap/schema_change.cpp b/be/src/olap/schema_change.cpp
index f4015fdcb3..4f8595b168 100644
--- a/be/src/olap/schema_change.cpp
+++ b/be/src/olap/schema_change.cpp
@@ -47,50 +47,6 @@ using namespace ErrorCode;
constexpr int ALTER_TABLE_BATCH_SIZE = 4096;
-class RowBlockSorter {
-public:
- explicit RowBlockSorter(RowBlockAllocator* allocator);
- virtual ~RowBlockSorter();
- size_t num_rows() { return _swap_row_block != nullptr ?
_swap_row_block->capacity() : 0; }
-
- bool sort(RowBlock** row_block);
-
-private:
- static bool _row_cursor_comparator(const std::unique_ptr<RowCursor>& a,
- const std::unique_ptr<RowCursor>& b) {
- return compare_row(*a, *b) < 0;
- }
-
- RowBlockAllocator* _row_block_allocator;
- RowBlock* _swap_row_block;
-};
-
-class RowBlockMerger {
-public:
- explicit RowBlockMerger(TabletSharedPtr tablet);
- virtual ~RowBlockMerger();
-
- bool merge(const std::vector<RowBlock*>& row_block_arr, RowsetWriter*
rowset_writer,
- uint64_t* merged_rows);
-
-private:
- struct MergeElement {
- bool operator<(const MergeElement& other) const {
- return compare_row(*row_cursor, *other.row_cursor) > 0;
- }
-
- const RowBlock* row_block;
- RowCursor* row_cursor;
- uint32_t row_block_index;
- };
-
- bool _make_heap(const std::vector<RowBlock*>& row_block_arr);
- void _pop_heap();
-
- TabletSharedPtr _tablet;
- std::priority_queue<MergeElement> _heap;
-};
-
class MultiBlockMerger {
public:
MultiBlockMerger(TabletSharedPtr tablet) : _tablet(tablet), _cmp(tablet) {}
@@ -261,524 +217,6 @@ ColumnMapping*
RowBlockChanger::get_mutable_column_mapping(size_t column_index)
return &(_schema_mapping[column_index]);
}
-#define TYPE_REINTERPRET_CAST(FromType, ToType) \
- { \
- size_t row_num = ref_block->row_block_info().row_num; \
- for (size_t row = 0, mutable_row = 0; row < row_num; ++row) { \
- char* ref_ptr = ref_block->field_ptr(row, ref_column); \
- char* new_ptr = mutable_block->field_ptr(mutable_row++, i); \
- *new_ptr = *ref_ptr; \
- *(ToType*)(new_ptr + 1) = *(FromType*)(ref_ptr + 1); \
- } \
- break; \
- }
-
-#define LARGEINT_REINTERPRET_CAST(FromType, ToType) \
- { \
- size_t row_num = ref_block->row_block_info().row_num; \
- for (size_t row = 0, mutable_row = 0; row < row_num; ++row) { \
- char* ref_ptr = ref_block->field_ptr(row, ref_column); \
- char* new_ptr = mutable_block->field_ptr(mutable_row++, i); \
- *new_ptr = *ref_ptr; \
- ToType new_value = *(FromType*)(ref_ptr + 1); \
- memcpy(new_ptr + 1, &new_value, sizeof(ToType)); \
- } \
- break; \
- }
-
-#define CONVERT_FROM_TYPE(from_type)
\
- {
\
- switch (newtype) {
\
- case OLAP_FIELD_TYPE_TINYINT:
\
- TYPE_REINTERPRET_CAST(from_type, int8_t);
\
- case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
\
- TYPE_REINTERPRET_CAST(from_type, uint8_t);
\
- case OLAP_FIELD_TYPE_SMALLINT:
\
- TYPE_REINTERPRET_CAST(from_type, int16_t);
\
- case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
\
- TYPE_REINTERPRET_CAST(from_type, uint16_t);
\
- case OLAP_FIELD_TYPE_INT:
\
- TYPE_REINTERPRET_CAST(from_type, int32_t);
\
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
\
- TYPE_REINTERPRET_CAST(from_type, uint32_t);
\
- case OLAP_FIELD_TYPE_BIGINT:
\
- TYPE_REINTERPRET_CAST(from_type, int64_t);
\
- case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
\
- TYPE_REINTERPRET_CAST(from_type, uint64_t);
\
- case OLAP_FIELD_TYPE_LARGEINT:
\
- LARGEINT_REINTERPRET_CAST(from_type, int128_t);
\
- case OLAP_FIELD_TYPE_FLOAT:
\
- TYPE_REINTERPRET_CAST(from_type, float);
\
- case OLAP_FIELD_TYPE_DOUBLE:
\
- TYPE_REINTERPRET_CAST(from_type, double);
\
- default:
\
- LOG(WARNING) << "the column type which was altered to was
unsupported." \
- << " origin_type="
\
- <<
ref_block->tablet_schema()->column(ref_column).type() \
- << ", alter_type=" <<
mutable_block->tablet_schema()->column(i).type(); \
- return Status::Error<SCHEMA_CHANGE_INFO_INVALID>();
\
- }
\
- break;
\
- }
-
-#define ASSIGN_DEFAULT_VALUE(length)
\
- case length: {
\
- for (size_t row = 0; row < ref_block.row_block_info().row_num; ++row)
{ \
- memcpy(buf, _schema_mapping[i].default_value->ptr(), length);
\
- buf += length;
\
- }
\
- break;
\
- }
-
-struct ConvertTypeMapHash {
- size_t operator()(const std::pair<FieldType, FieldType>& pair) const {
- return (pair.first + 31) ^ pair.second;
- }
-};
-
-class ConvertTypeResolver {
- DECLARE_SINGLETON(ConvertTypeResolver);
-
-public:
- bool get_convert_type_info(const FieldType from_type, const FieldType
to_type) const {
- return _convert_type_set.find(std::make_pair(from_type, to_type)) !=
- _convert_type_set.end();
- }
-
- template <FieldType from_type, FieldType to_type>
- void add_convert_type_mapping() {
- _convert_type_set.emplace(std::make_pair(from_type, to_type));
- }
-
-private:
- using convert_type_pair = std::pair<FieldType, FieldType>;
- std::unordered_set<convert_type_pair, ConvertTypeMapHash>
_convert_type_set;
-
- DISALLOW_COPY_AND_ASSIGN(ConvertTypeResolver);
-};
-
-ConvertTypeResolver::ConvertTypeResolver() {
- // from char type
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_TINYINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_SMALLINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_INT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_BIGINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_LARGEINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_FLOAT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_DOUBLE>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_DATE>();
-
- // supported type convert should annotate in doc:
- //
http://doris.apache.org/master/zh-CN/sql-reference/sql-statements/Data%20Definition/ALTER%20TABLE.html#description
- // If type convert is supported here, you should check
fe/src/main/java/org/apache/doris/catalog/ColumnType.java to supported it either
- // from varchar type
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_TYPE_TINYINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_TYPE_SMALLINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR, OLAP_FIELD_TYPE_INT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_TYPE_BIGINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_TYPE_LARGEINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR, OLAP_FIELD_TYPE_FLOAT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_TYPE_DOUBLE>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR, OLAP_FIELD_TYPE_DATE>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_TYPE_STRING>();
-
- // to varchar type
- add_convert_type_mapping<OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_INT, OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_BIGINT,
OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_LARGEINT,
OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_FLOAT, OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_DOUBLE,
OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_DECIMAL,
OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_VARCHAR>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING,
OLAP_FIELD_TYPE_VARCHAR>();
-
- // from string
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING,
OLAP_FIELD_TYPE_TINYINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING,
OLAP_FIELD_TYPE_SMALLINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING, OLAP_FIELD_TYPE_INT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING, OLAP_FIELD_TYPE_BIGINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING,
OLAP_FIELD_TYPE_LARGEINT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING, OLAP_FIELD_TYPE_FLOAT>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING, OLAP_FIELD_TYPE_DOUBLE>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING, OLAP_FIELD_TYPE_DATE>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING,
OLAP_FIELD_TYPE_VARCHAR>();
-
- // to string
- add_convert_type_mapping<OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_INT, OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_BIGINT, OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_LARGEINT,
OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_FLOAT, OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_DOUBLE, OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_DECIMAL,
OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_CHAR, OLAP_FIELD_TYPE_STRING>();
- add_convert_type_mapping<OLAP_FIELD_TYPE_STRING, OLAP_FIELD_TYPE_STRING>();
-
- add_convert_type_mapping<OLAP_FIELD_TYPE_DATE, OLAP_FIELD_TYPE_DATETIME>();
-
- add_convert_type_mapping<OLAP_FIELD_TYPE_DATETIME, OLAP_FIELD_TYPE_DATE>();
-
- add_convert_type_mapping<OLAP_FIELD_TYPE_FLOAT, OLAP_FIELD_TYPE_DOUBLE>();
-
- add_convert_type_mapping<OLAP_FIELD_TYPE_INT, OLAP_FIELD_TYPE_DATE>();
-}
-
-ConvertTypeResolver::~ConvertTypeResolver() = default;
-
-bool to_bitmap(RowCursor* read_helper, RowCursor* write_helper, const
TabletColumn& ref_column,
- int field_idx, int ref_field_idx, MemPool* mem_pool) {
- write_helper->set_not_null(field_idx);
- BitmapValue bitmap;
- if (!read_helper->is_null(ref_field_idx)) {
- uint64_t origin_value;
- char* src = read_helper->cell_ptr(ref_field_idx);
- switch (ref_column.type()) {
- case OLAP_FIELD_TYPE_TINYINT:
- if (*(int8_t*)src < 0) {
- LOG(WARNING)
- << "The input: " << *(int8_t*)src
- << " is not valid, to_bitmap only support bigint value
from 0 to "
- "18446744073709551615 currently, cannot create MV
with to_bitmap on "
- "column with negative values.";
- return false;
- }
- origin_value = *(int8_t*)src;
- break;
- case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
- origin_value = *(uint8_t*)src;
- break;
- case OLAP_FIELD_TYPE_SMALLINT:
- if (*(int16_t*)src < 0) {
- LOG(WARNING)
- << "The input: " << *(int16_t*)src
- << " is not valid, to_bitmap only support bigint value
from 0 to "
- "18446744073709551615 currently, cannot create MV
with to_bitmap on "
- "column with negative values.";
- return false;
- }
- origin_value = *(int16_t*)src;
- break;
- case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
- origin_value = *(uint16_t*)src;
- break;
- case OLAP_FIELD_TYPE_INT:
- if (*(int32_t*)src < 0) {
- LOG(WARNING)
- << "The input: " << *(int32_t*)src
- << " is not valid, to_bitmap only support bigint value
from 0 to "
- "18446744073709551615 currently, cannot create MV
with to_bitmap on "
- "column with negative values.";
- return false;
- }
- origin_value = *(int32_t*)src;
- break;
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
- origin_value = *(uint32_t*)src;
- break;
- case OLAP_FIELD_TYPE_BIGINT:
- if (*(int64_t*)src < 0) {
- LOG(WARNING)
- << "The input: " << *(int64_t*)src
- << " is not valid, to_bitmap only support bigint value
from 0 to "
- "18446744073709551615 currently, cannot create MV
with to_bitmap on "
- "column with negative values.";
- return false;
- }
- origin_value = *(int64_t*)src;
- break;
- case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
- origin_value = *(uint64_t*)src;
- break;
- default:
- LOG(WARNING) << "the column type which was altered from was
unsupported."
- << " from_type=" << ref_column.type();
- return false;
- }
- bitmap.add(origin_value);
- }
- char* buf =
reinterpret_cast<char*>(mem_pool->allocate(bitmap.getSizeInBytes()));
- Slice dst(buf, bitmap.getSizeInBytes());
- bitmap.write(dst.data);
- write_helper->set_field_content(field_idx, reinterpret_cast<char*>(&dst),
mem_pool);
- return true;
-}
-
-bool hll_hash(RowCursor* read_helper, RowCursor* write_helper, const
TabletColumn& ref_column,
- int field_idx, int ref_field_idx, MemPool* mem_pool) {
- write_helper->set_not_null(field_idx);
- HyperLogLog hll;
- if (!read_helper->is_null(ref_field_idx)) {
- uint64_t hash_value;
-
- switch (ref_column.type()) {
- case OLAP_FIELD_TYPE_CHAR: {
- int p = ref_column.length() - 1;
- Slice* slice =
reinterpret_cast<Slice*>(read_helper->cell_ptr(ref_field_idx));
- char* buf = slice->data;
- while (p >= 0 && buf[p] == '\0') {
- p--;
- }
- slice->size = p + 1;
- }
-
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_STRING: {
- Slice slice =
*reinterpret_cast<Slice*>(read_helper->cell_ptr(ref_field_idx));
- hash_value = HashUtil::murmur_hash64A(slice.data, slice.size,
HashUtil::MURMUR_SEED);
- break;
- }
- case OLAP_FIELD_TYPE_BOOL:
- case OLAP_FIELD_TYPE_TINYINT:
- case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
- case OLAP_FIELD_TYPE_SMALLINT:
- case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
- case OLAP_FIELD_TYPE_INT:
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
- case OLAP_FIELD_TYPE_BIGINT:
- case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
- case OLAP_FIELD_TYPE_LARGEINT:
- case OLAP_FIELD_TYPE_FLOAT:
- case OLAP_FIELD_TYPE_DOUBLE:
- case OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
- case OLAP_FIELD_TYPE_DATE:
- case OLAP_FIELD_TYPE_DATETIME: {
- std::string ref_column_string =
- read_helper->column_schema(ref_field_idx)
- ->type_info()
- ->to_string(read_helper->cell_ptr(ref_field_idx));
- hash_value = HashUtil::murmur_hash64A(
- ref_column_string.c_str(), ref_column_string.length(),
HashUtil::MURMUR_SEED);
- break;
- }
- default:
- LOG(WARNING) << "fail to hll hash type : " << ref_column.type();
- return false;
- }
-
- hll.update(hash_value);
- }
- std::string buf;
- buf.resize(hll.max_serialized_size());
- buf.resize(hll.serialize((uint8_t*)buf.c_str()));
- Slice dst(buf);
- write_helper->set_field_content(field_idx, reinterpret_cast<char*>(&dst),
mem_pool);
- return true;
-}
-
-bool count_field(RowCursor* read_helper, RowCursor* write_helper, const
TabletColumn& ref_column,
- int field_idx, int ref_field_idx, MemPool* mem_pool) {
- write_helper->set_not_null(field_idx);
- int64_t count = read_helper->is_null(ref_field_idx) ? 0 : 1;
- write_helper->set_field_content(field_idx, (char*)&count, mem_pool);
- return true;
-}
-
-Status RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t
data_version,
- RowBlock* mutable_block,
- const uint64_t* filtered_rows) const {
- if (mutable_block == nullptr) {
- LOG(FATAL) << "mutable block is uninitialized.";
- return Status::Error<UNINITIALIZED>();
- } else if (mutable_block->tablet_schema()->num_columns() !=
_schema_mapping.size()) {
- LOG(WARNING) << "mutable block does not match with schema mapping
rules. "
- << "block_schema_size=" <<
mutable_block->tablet_schema()->num_columns()
- << ", mapping_schema_size=" << _schema_mapping.size();
- return Status::Error<UNINITIALIZED>();
- }
-
- if (mutable_block->capacity() < ref_block->row_block_info().row_num) {
- LOG(WARNING) << "mutable block is not large enough for storing the
changed block. "
- << "mutable_block_size=" << mutable_block->capacity()
- << ", ref_block_row_num=" <<
ref_block->row_block_info().row_num;
- return Status::Error<UNINITIALIZED>();
- }
-
- mutable_block->clear();
-
- RowCursor write_helper;
- if (write_helper.init(mutable_block->tablet_schema()) != Status::OK()) {
- LOG(WARNING) << "fail to init rowcursor.";
- return Status::Error<UNINITIALIZED>();
- }
-
- RowCursor read_helper;
- if (read_helper.init(ref_block->tablet_schema()) != Status::OK()) {
- LOG(WARNING) << "fail to init rowcursor.";
- return Status::Error<UNINITIALIZED>();
- }
-
- // a.1 First determine whether the data needs to be filtered, and finally
only those marked as 1 are left as needed
- // For those without filter, it is equivalent to leave after setting all
to 1
- const uint32_t row_num = ref_block->row_block_info().row_num;
-
- // a.2 Calculate the left row num
- uint32_t new_row_num = row_num - *filtered_rows;
-
- const bool filter_all = (new_row_num == 0);
-
- MemPool* mem_pool = mutable_block->mem_pool();
- // b. According to the previous filtering information, only processes that
are also marked as 1
- for (size_t i = 0, len = mutable_block->tablet_schema()->num_columns();
!filter_all && i < len;
- ++i) {
- int32_t ref_column = _schema_mapping[i].ref_column;
- if (_schema_mapping[i].ref_column >= 0) {
- if (!_schema_mapping[i].materialized_function.empty()) {
- bool (*_do_materialized_transform)(RowCursor*, RowCursor*,
const TabletColumn&, int,
- int, MemPool*) = nullptr;
- if (_schema_mapping[i].materialized_function == "to_bitmap" ||
- _schema_mapping[i].materialized_function ==
"to_bitmap_with_check") {
- _do_materialized_transform = to_bitmap;
- } else if (_schema_mapping[i].materialized_function ==
"hll_hash") {
- _do_materialized_transform = hll_hash;
- } else if (_schema_mapping[i].materialized_function ==
"count_field") {
- _do_materialized_transform = count_field;
- } else {
- LOG(WARNING) << "error materialized view function : "
- << _schema_mapping[i].materialized_function;
- return Status::Error<SCHEMA_CHANGE_INFO_INVALID>();
- }
- VLOG_NOTICE << "_schema_mapping[" << i <<
"].materialized_function : "
- << _schema_mapping[i].materialized_function;
- for (size_t row_index = 0, new_row_index = 0;
- row_index < ref_block->row_block_info().row_num;
++row_index) {
- mutable_block->get_row(new_row_index++, &write_helper);
- ref_block->get_row(row_index, &read_helper);
-
- if (!_do_materialized_transform(&read_helper,
&write_helper,
-
ref_block->tablet_schema()->column(ref_column),
- i,
_schema_mapping[i].ref_column, mem_pool)) {
- return Status::Error<DATA_QUALITY_ERR>();
- }
- }
- continue;
- }
-
- // new column will be assigned as referenced column
- // check if the type of new column is equal to the older's.
- FieldType reftype =
ref_block->tablet_schema()->column(ref_column).type();
- FieldType newtype =
mutable_block->tablet_schema()->column(i).type();
- if (newtype == reftype) {
- // Low efficiency, you can also directly calculate the
variable length domain copy, but it will still destroy the package
- for (size_t row_index = 0, new_row_index = 0;
- row_index < ref_block->row_block_info().row_num;
++row_index) {
- // Specify the new row index to be written (different from
the read row_index)
- mutable_block->get_row(new_row_index++, &write_helper);
- ref_block->get_row(row_index, &read_helper);
-
- if (read_helper.is_null(ref_column)) {
- write_helper.set_null(i);
- } else {
- write_helper.set_not_null(i);
- if (newtype == OLAP_FIELD_TYPE_CHAR) {
- // if modify length of CHAR type, the size of
slice should be equal
- // to new length.
- Slice* src =
(Slice*)(read_helper.cell_ptr(ref_column));
- size_t size =
mutable_block->tablet_schema()->column(i).length();
- char* buf =
reinterpret_cast<char*>(mem_pool->allocate(size));
- memset(buf, 0, size);
- size_t copy_size = (size < src->size) ? size :
src->size;
- memcpy(buf, src->data, copy_size);
- Slice dst(buf, size);
- write_helper.set_field_content(i,
reinterpret_cast<char*>(&dst),
- mem_pool);
- } else {
- char* src = read_helper.cell_ptr(ref_column);
- write_helper.set_field_content(i, src, mem_pool);
- }
- }
- }
- } else if
(ConvertTypeResolver::instance()->get_convert_type_info(reftype, newtype)) {
- for (size_t row_index = 0, new_row_index = 0;
- row_index < ref_block->row_block_info().row_num;
++row_index) {
- mutable_block->get_row(new_row_index++, &write_helper);
- ref_block->get_row(row_index, &read_helper);
- if (read_helper.is_null(ref_column)) {
- write_helper.set_null(i);
- } else {
- write_helper.set_not_null(i);
- const Field* ref_field =
read_helper.column_schema(ref_column);
- char* ref_value = read_helper.cell_ptr(ref_column);
- Status st = write_helper.convert_from(i, ref_value,
ref_field->type_info(),
- mem_pool);
- if (!st) {
- LOG(WARNING)
- << "the column type which was altered from
was unsupported."
- << "status:" << st.to_string() << ",
from_type=" << reftype
- << ", to_type=" << newtype;
- return st;
- }
- }
- }
- // Write column i from ref_column.
- } else {
- // copy and alter the field
- // You can stay here for the time being, the new type does not
involve type conversion for the time being
- switch (reftype) {
- case OLAP_FIELD_TYPE_TINYINT:
- CONVERT_FROM_TYPE(int8_t);
- case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
- CONVERT_FROM_TYPE(uint8_t);
- case OLAP_FIELD_TYPE_SMALLINT:
- CONVERT_FROM_TYPE(int16_t);
- case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
- CONVERT_FROM_TYPE(uint16_t);
- case OLAP_FIELD_TYPE_INT:
- CONVERT_FROM_TYPE(int32_t);
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
- CONVERT_FROM_TYPE(uint32_t);
- case OLAP_FIELD_TYPE_BIGINT:
- CONVERT_FROM_TYPE(int64_t);
- case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
- CONVERT_FROM_TYPE(uint64_t);
- case OLAP_FIELD_TYPE_LARGEINT:
- CONVERT_FROM_TYPE(int128_t);
- default:
- LOG(WARNING) << "the column type which was altered from
was unsupported."
- << " from_type="
- <<
ref_block->tablet_schema()->column(ref_column).type();
- return Status::Error<SCHEMA_CHANGE_INFO_INVALID>();
- }
-
- if (newtype < reftype) {
- VLOG_NOTICE << "type degraded while altering column. "
- << "column=" <<
mutable_block->tablet_schema()->column(i).name()
- << ", origin_type="
- <<
ref_block->tablet_schema()->column(ref_column).type()
- << ", alter_type="
- <<
mutable_block->tablet_schema()->column(i).type();
- }
- }
- } else {
- // New column, write default value
- for (size_t row_index = 0, new_row_index = 0;
- row_index < ref_block->row_block_info().row_num; ++row_index)
{
- mutable_block->get_row(new_row_index++, &write_helper);
-
- if (_schema_mapping[i].default_value->is_null()) {
- write_helper.set_null(i);
- } else {
- write_helper.set_not_null(i);
- write_helper.set_field_content(i,
_schema_mapping[i].default_value->ptr(),
- mem_pool);
- }
- }
- }
- }
-
- // NOTE The current row_num of mutable_block is still as much as ref
- // (Actually, you can re-init into less when init, the new_row_num left by
the filter)
- // In split_table, there may be no data due to filtering
- mutable_block->finalize(new_row_num);
- return Status::OK();
-}
-
-#undef CONVERT_FROM_TYPE
-#undef TYPE_REINTERPRET_CAST
-#undef ASSIGN_DEFAULT_VALUE
-
Status RowBlockChanger::change_block(vectorized::Block* ref_block,
vectorized::Block* new_block) const {
if (new_block->columns() != _schema_mapping.size()) {
@@ -931,250 +369,6 @@ Status
RowBlockChanger::_check_cast_valid(vectorized::ColumnPtr ref_column,
return Status::OK();
}
-RowBlockSorter::RowBlockSorter(RowBlockAllocator* row_block_allocator)
- : _row_block_allocator(row_block_allocator), _swap_row_block(nullptr)
{}
-
-RowBlockSorter::~RowBlockSorter() {
- if (_swap_row_block) {
- _row_block_allocator->release(_swap_row_block);
- _swap_row_block = nullptr;
- }
-}
-
-bool RowBlockSorter::sort(RowBlock** row_block) {
- uint32_t row_num = (*row_block)->row_block_info().row_num;
- bool null_supported = (*row_block)->row_block_info().null_supported;
-
- if (_swap_row_block == nullptr || _swap_row_block->capacity() < row_num) {
- if (_swap_row_block != nullptr) {
- _row_block_allocator->release(_swap_row_block);
- _swap_row_block = nullptr;
- }
-
- if (!_row_block_allocator->allocate(&_swap_row_block, row_num,
null_supported)) {
- LOG(WARNING) << "fail to allocate memory.";
- return false;
- }
- }
-
- RowCursor helper_row;
- auto res = helper_row.init(_swap_row_block->tablet_schema());
- if (!res) {
- LOG(WARNING) << "row cursor init failed.res:" << res;
- return false;
- }
-
- std::vector<std::unique_ptr<RowCursor>> row_cursor_list;
- row_cursor_list.reserve((*row_block)->row_block_info().row_num);
- // create an list of row cursor as long as the number of rows in data
block.
- for (size_t i = 0; i < (*row_block)->row_block_info().row_num; ++i) {
- row_cursor_list.emplace_back(new (nothrow) RowCursor());
- if (row_cursor_list[i] == nullptr) {
- LOG(WARNING) << "failed to malloc RowCursor. size=" <<
sizeof(RowCursor);
- return false;
- }
-
- if (row_cursor_list[i]->init((*row_block)->tablet_schema()) !=
Status::OK()) {
- return false;
- }
-
- (*row_block)->get_row(i, row_cursor_list[i].get());
- }
-
- // Must use 'std::' because this class has a function whose name is sort
too
- std::stable_sort(row_cursor_list.begin(), row_cursor_list.end(),
_row_cursor_comparator);
-
- // copy the results sorted to temp row block.
- _swap_row_block->clear();
- for (size_t i = 0; i < row_cursor_list.size(); ++i) {
- _swap_row_block->get_row(i, &helper_row);
- copy_row(&helper_row, *row_cursor_list[i],
_swap_row_block->mem_pool());
- }
-
- _swap_row_block->finalize(row_cursor_list.size());
-
- // swap the row block for reducing memory allocating.
- std::swap(*row_block, _swap_row_block);
-
- return true;
-}
-
-RowBlockAllocator::RowBlockAllocator(TabletSchemaSPtr tablet_schema, size_t
memory_limitation)
- : _tablet_schema(tablet_schema),
- _tracker(std::make_unique<MemTracker>("RowBlockAllocator")),
- _row_len(tablet_schema->row_size()),
- _memory_limitation(memory_limitation) {
- VLOG_NOTICE << "RowBlockAllocator(). row_len=" << _row_len;
-}
-
-RowBlockAllocator::~RowBlockAllocator() {
- if (_tracker->consumption() != 0) {
- LOG(WARNING) << "memory lost in RowBlockAllocator. memory_size=" <<
_tracker->consumption();
- }
-}
-
-Status RowBlockAllocator::allocate(RowBlock** row_block, size_t num_rows, bool
null_supported) {
- size_t row_block_size = _row_len * num_rows;
-
- if (_memory_limitation > 0 && _tracker->consumption() + row_block_size >
_memory_limitation) {
- *row_block = nullptr;
- return Status::Error<FETCH_MEMORY_EXCEEDED>();
- }
-
- // TODO(lijiao) : Why abandon the original m_row_block_buffer
- *row_block = new (nothrow) RowBlock(_tablet_schema);
-
- if (*row_block == nullptr) {
- LOG(WARNING) << "failed to malloc RowBlock. size=" << sizeof(RowBlock);
- return Status::Error<MEM_ALLOC_FAILED>();
- }
-
- RowBlockInfo row_block_info(0U, num_rows);
- row_block_info.null_supported = null_supported;
- (*row_block)->init(row_block_info);
-
- _tracker->consume(row_block_size);
- VLOG_NOTICE << "RowBlockAllocator::allocate() this=" << this << ",
num_rows=" << num_rows
- << ", m_memory_allocated=" << _tracker->consumption()
- << ", row_block_addr=" << *row_block;
- return Status::OK();
-}
-
-void RowBlockAllocator::release(RowBlock* row_block) {
- if (row_block == nullptr) {
- LOG(INFO) << "null row block released.";
- return;
- }
-
- _tracker->release(row_block->capacity() * _row_len);
-
- VLOG_NOTICE << "RowBlockAllocator::release() this=" << this
- << ", num_rows=" << row_block->capacity()
- << ", m_memory_allocated=" << _tracker->consumption()
- << ", row_block_addr=" << row_block;
- delete row_block;
-}
-
-bool RowBlockAllocator::is_memory_enough_for_sorting(size_t num_rows, size_t
allocated_rows) {
- if (num_rows <= allocated_rows) {
- return true;
- }
- size_t row_block_size = _row_len * (num_rows - allocated_rows);
- return _tracker->consumption() + row_block_size < _memory_limitation;
-}
-
-RowBlockMerger::RowBlockMerger(TabletSharedPtr tablet) : _tablet(tablet) {}
-
-RowBlockMerger::~RowBlockMerger() = default;
-
-bool RowBlockMerger::merge(const std::vector<RowBlock*>& row_block_arr,
RowsetWriter* rowset_writer,
- uint64_t* merged_rows) {
- uint64_t tmp_merged_rows = 0;
- RowCursor row_cursor;
- std::unique_ptr<MemPool> mem_pool(new MemPool());
- std::unique_ptr<ObjectPool> agg_object_pool(new ObjectPool());
-
- auto merge_error = [&]() -> bool {
- while (!_heap.empty()) {
- MergeElement element = _heap.top();
- _heap.pop();
- SAFE_DELETE(element.row_cursor);
- }
- return false;
- };
-
- if (row_cursor.init(_tablet->tablet_schema()) != Status::OK()) {
- LOG(WARNING) << "fail to init row cursor.";
- return merge_error();
- }
-
- if (!_make_heap(row_block_arr)) {
- // There is error log in _make_heap, so no need to more log.
- return merge_error();
- }
-
- row_cursor.allocate_memory_for_string_type(_tablet->tablet_schema());
- while (_heap.size() > 0) {
- init_row_with_others(&row_cursor, *(_heap.top().row_cursor),
mem_pool.get(),
- agg_object_pool.get());
-
- _pop_heap();
-
- if (KeysType::DUP_KEYS == _tablet->keys_type()) {
- if (rowset_writer->add_row(row_cursor) != Status::OK()) {
- LOG(WARNING) << "fail to add row to rowset writer.";
- return merge_error();
- }
- continue;
- }
-
- while (!_heap.empty() && compare_row(row_cursor,
*_heap.top().row_cursor) == 0) {
- // TODO(zc): Currently we keep nullptr to indicate that this is a
query path,
- // we should fix this trick ASAP
- agg_update_row(&row_cursor, *(_heap.top().row_cursor), nullptr);
- ++tmp_merged_rows;
- _pop_heap();
- }
- agg_finalize_row(&row_cursor, mem_pool.get());
- if (rowset_writer->add_row(row_cursor) != Status::OK()) {
- LOG(WARNING) << "fail to add row to rowset writer.";
- return merge_error();
- }
-
- // the memory allocate by mem pool has been copied,
- // so we should release memory immediately
- mem_pool->clear();
- agg_object_pool.reset(new ObjectPool());
- }
- if (rowset_writer->flush() != Status::OK()) {
- LOG(WARNING) << "failed to finalizing writer.";
- return merge_error();
- }
-
- *merged_rows = tmp_merged_rows;
- return true;
-}
-
-bool RowBlockMerger::_make_heap(const std::vector<RowBlock*>& row_block_arr) {
- for (auto row_block : row_block_arr) {
- MergeElement element;
- element.row_block = row_block;
- element.row_block_index = 0;
- element.row_cursor = new (nothrow) RowCursor();
-
- if (element.row_cursor == nullptr) {
- LOG(FATAL) << "failed to malloc RowCursor. size=" <<
sizeof(RowCursor);
- return false;
- }
-
- if (element.row_cursor->init(element.row_block->tablet_schema()) !=
Status::OK()) {
- LOG(WARNING) << "failed to init row cursor.";
- SAFE_DELETE(element.row_cursor);
- return false;
- }
-
- element.row_block->get_row(element.row_block_index,
element.row_cursor);
-
- _heap.push(element);
- }
-
- return true;
-}
-
-void RowBlockMerger::_pop_heap() {
- MergeElement element = _heap.top();
- _heap.pop();
-
- if (++element.row_block_index >=
element.row_block->row_block_info().row_num) {
- SAFE_DELETE(element.row_cursor);
- return;
- }
-
- element.row_block->get_row(element.row_block_index, element.row_cursor);
-
- _heap.push(element);
-}
-
Status LinkedSchemaChange::process(RowsetReaderSharedPtr rowset_reader,
RowsetWriter* rowset_writer,
TabletSharedPtr new_tablet, TabletSharedPtr
base_tablet,
TabletSchemaSPtr base_tablet_schema) {
@@ -1218,24 +412,6 @@ Status LinkedSchemaChange::process(RowsetReaderSharedPtr
rowset_reader, RowsetWr
}
}
-Status reserve_block(std::unique_ptr<RowBlock, RowBlockDeleter>*
block_handle_ptr, int row_num,
- RowBlockAllocator* allocator) {
- auto& block_handle = *block_handle_ptr;
- if (block_handle == nullptr || block_handle->capacity() < row_num) {
- // release old block and alloc new block
- if (block_handle != nullptr) {
- block_handle.reset();
- }
- RowBlock* new_row_block = nullptr;
- auto res = allocator->allocate(&new_row_block, row_num, true);
- RETURN_NOT_OK_LOG(res, "failed to allocate RowBlock.");
- block_handle.reset(new_row_block);
- } else {
- block_handle->clear();
- }
- return Status::OK();
-}
-
Status VSchemaChangeDirectly::_inner_process(RowsetReaderSharedPtr
rowset_reader,
RowsetWriter* rowset_writer,
TabletSharedPtr new_tablet,
diff --git a/be/src/olap/schema_change.h b/be/src/olap/schema_change.h
index c9ffd1cdd9..40e4b02270 100644
--- a/be/src/olap/schema_change.h
+++ b/be/src/olap/schema_change.h
@@ -28,14 +28,6 @@
#include "vec/core/block.h"
namespace doris {
-
-bool to_bitmap(RowCursor* read_helper, RowCursor* write_helper, const
TabletColumn& ref_column,
- int field_idx, int ref_field_idx, MemPool* mem_pool);
-bool hll_hash(RowCursor* read_helper, RowCursor* write_helper, const
TabletColumn& ref_column,
- int field_idx, int ref_field_idx, MemPool* mem_pool);
-bool count_field(RowCursor* read_helper, RowCursor* write_helper, const
TabletColumn& ref_column,
- int field_idx, int ref_field_idx, MemPool* mem_pool);
-
class RowBlockChanger {
public:
RowBlockChanger(TabletSchemaSPtr tablet_schema, const DeleteHandler*
delete_handler,
@@ -45,9 +37,6 @@ public:
ColumnMapping* get_mutable_column_mapping(size_t column_index);
- Status change_row_block(const RowBlock* ref_block, int32_t data_version,
- RowBlock* mutable_block, const uint64_t*
filtered_rows) const;
-
Status change_block(vectorized::Block* ref_block, vectorized::Block*
new_block) const;
private:
@@ -65,22 +54,6 @@ private:
DISALLOW_COPY_AND_ASSIGN(RowBlockChanger);
};
-class RowBlockAllocator {
-public:
- RowBlockAllocator(TabletSchemaSPtr tablet_schema, size_t
memory_limitation);
- virtual ~RowBlockAllocator();
-
- Status allocate(RowBlock** row_block, size_t num_rows, bool
null_supported);
- void release(RowBlock* row_block);
- bool is_memory_enough_for_sorting(size_t num_rows, size_t allocated_rows);
-
-private:
- TabletSchemaSPtr _tablet_schema;
- std::unique_ptr<MemTracker> _tracker;
- size_t _row_len;
- size_t _memory_limitation;
-};
-
class SchemaChange {
public:
SchemaChange() : _filtered_rows(0), _merged_rows(0) {}
@@ -262,6 +235,4 @@ private:
static std::unordered_set<int64_t> _tablet_ids_in_converting;
static std::set<std::string> _supported_functions;
};
-
-using RowBlockDeleter = std::function<void(RowBlock*)>;
} // namespace doris
diff --git a/be/src/util/tuple_row_zorder_compare.cpp
b/be/src/util/tuple_row_zorder_compare.cpp
index 4f66a60ded..25bb270eeb 100644
--- a/be/src/util/tuple_row_zorder_compare.cpp
+++ b/be/src/util/tuple_row_zorder_compare.cpp
@@ -25,208 +25,4 @@ int RowComparator::operator()(const char* left, const char*
right) const {
return -1;
}
-TupleRowZOrderComparator::TupleRowZOrderComparator() {
- _schema = nullptr;
- _sort_col_num = 0;
-}
-
-TupleRowZOrderComparator::TupleRowZOrderComparator(int sort_col_num) {
- _schema = nullptr;
- _sort_col_num = sort_col_num;
-}
-
-TupleRowZOrderComparator::TupleRowZOrderComparator(Schema* schema, int
sort_col_num)
- : _schema(schema), _sort_col_num(sort_col_num) {
- _max_col_size = get_type_byte_size(_schema->column(0)->type());
- for (size_t i = 1; i < _sort_col_num; ++i) {
- if (_max_col_size < get_type_byte_size(_schema->column(i)->type())) {
- _max_col_size = get_type_byte_size(_schema->column(i)->type());
- }
- }
-}
-
-int TupleRowZOrderComparator::compare(const char* lhs, const char* rhs) const {
- ContiguousRow lhs_row(_schema, lhs);
- ContiguousRow rhs_row(_schema, rhs);
- if (_max_col_size <= 4) {
- return compare_based_on_size<uint32_t, ContiguousRow>(lhs_row,
rhs_row);
- } else if (_max_col_size <= 8) {
- return compare_based_on_size<uint64_t, ContiguousRow>(lhs_row,
rhs_row);
- } else {
- return compare_based_on_size<uint128_t, ContiguousRow>(lhs_row,
rhs_row);
- }
-}
-
-void TupleRowZOrderComparator::max_col_size(const RowCursor& rc) {
- _max_col_size = get_type_byte_size(rc.schema()->column(0)->type());
- for (size_t i = 1; i < _sort_col_num; ++i) {
- if (_max_col_size <
get_type_byte_size(rc.schema()->column(i)->type())) {
- _max_col_size = get_type_byte_size(rc.schema()->column(i)->type());
- }
- }
-}
-
-int TupleRowZOrderComparator::compare_row(const RowCursor& lhs, const
RowCursor& rhs) {
- max_col_size(lhs);
- if (_max_col_size <= 4) {
- return compare_based_on_size<uint32_t, const RowCursor>(lhs, rhs);
- } else if (_max_col_size <= 8) {
- return compare_based_on_size<uint64_t, const RowCursor>(lhs, lhs);
- } else {
- return compare_based_on_size<uint128_t, const RowCursor>(lhs, lhs);
- }
-}
-
-template <typename U, typename LhsRowType>
-int TupleRowZOrderComparator::compare_based_on_size(LhsRowType& lhs,
LhsRowType& rhs) const {
- auto less_msb = [](U x, U y) { return x < y && x < (x ^ y); };
- FieldType type = lhs.schema()->column(0)->type();
- U msd_lhs = get_shared_representation<U>(
- lhs.cell(0).is_null() ? nullptr : lhs.cell(0).cell_ptr(), type);
- U msd_rhs = get_shared_representation<U>(
- rhs.cell(0).is_null() ? nullptr : rhs.cell(0).cell_ptr(), type);
- for (int i = 1; i < _sort_col_num; ++i) {
- type = lhs.schema()->column(i)->type();
- const void* lhs_v = lhs.cell(i).is_null() ? nullptr :
lhs.cell(i).cell_ptr();
- const void* rhs_v = rhs.cell(i).is_null() ? nullptr :
rhs.cell(i).cell_ptr();
- U lhsi = get_shared_representation<U>(lhs_v, type);
- U rhsi = get_shared_representation<U>(rhs_v, type);
- if (less_msb(msd_lhs ^ msd_rhs, lhsi ^ rhsi)) {
- msd_lhs = lhsi;
- msd_rhs = rhsi;
- }
- }
- return msd_lhs < msd_rhs ? -1 : (msd_lhs > msd_rhs ? 1 : 0);
-}
-
-template <typename U>
-U TupleRowZOrderComparator::get_shared_representation(const void* val,
FieldType type) const {
- // The mask used for setting the sign bit correctly.
- if (val == NULL) return 0;
- constexpr U mask = (U)1 << (sizeof(U) * 8 - 1);
- switch (type) {
- case FieldType::OLAP_FIELD_TYPE_NONE:
- return 0;
- case FieldType::OLAP_FIELD_TYPE_BOOL:
- return static_cast<U>(*reinterpret_cast<const bool*>(val)) <<
(sizeof(U) * 8 - 1);
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
- case FieldType::OLAP_FIELD_TYPE_TINYINT:
- return get_shared_int_representation<U,
int8_t>(*reinterpret_cast<const int8_t*>(val),
- mask);
- case FieldType::OLAP_FIELD_TYPE_SMALLINT:
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
- return get_shared_int_representation<U,
int16_t>(*reinterpret_cast<const int16_t*>(val),
- mask);
- case FieldType::OLAP_FIELD_TYPE_INT:
- return get_shared_int_representation<U,
int32_t>(*reinterpret_cast<const int32_t*>(val),
- mask);
- case FieldType::OLAP_FIELD_TYPE_DATETIME:
- case FieldType::OLAP_FIELD_TYPE_DATE:
- case FieldType::OLAP_FIELD_TYPE_BIGINT:
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
- return get_shared_int_representation<U,
int64_t>(*reinterpret_cast<const int64_t*>(val),
- mask);
- case FieldType::OLAP_FIELD_TYPE_LARGEINT:
- return static_cast<U>(*reinterpret_cast<const int128_t*>(val)) ^ mask;
- case FieldType::OLAP_FIELD_TYPE_FLOAT:
- return get_shared_float_representation<U, float>(val, mask);
- case FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
- case FieldType::OLAP_FIELD_TYPE_DOUBLE:
- return get_shared_float_representation<U, double>(val, mask);
- case FieldType::OLAP_FIELD_TYPE_CHAR:
- case FieldType::OLAP_FIELD_TYPE_VARCHAR: {
- const StringValue* string_value = reinterpret_cast<const
StringValue*>(val);
- return get_shared_string_representation<U>(string_value->ptr,
string_value->len);
- }
- case FieldType::OLAP_FIELD_TYPE_DECIMAL: {
- decimal12_t decimal_val = *reinterpret_cast<const decimal12_t*>(val);
- int128_t value = decimal_val.integer * DecimalV2Value::ONE_BILLION +
decimal_val.fraction;
- return static_cast<U>(value) ^ mask;
- }
- default:
- return 0;
- }
-}
-
-template <typename U, typename T>
-U TupleRowZOrderComparator::get_shared_int_representation(const T val, U mask)
const {
- uint64_t shift_size = static_cast<uint64_t>(
- std::max(static_cast<int64_t>((sizeof(U) - sizeof(T)) * 8),
(int64_t)0));
- return (static_cast<U>(val) << shift_size) ^ mask;
-}
-
-template <typename U, typename T>
-U TupleRowZOrderComparator::get_shared_float_representation(const void* val, U
mask) const {
- int64_t tmp;
- T floating_value = *reinterpret_cast<const T*>(val);
- memcpy(&tmp, &floating_value, sizeof(T));
- if (UNLIKELY(std::isnan(floating_value))) return 0;
- // "int" is enough because U and T are only primitive type
- int s = (int)((sizeof(U) - sizeof(T)) * 8);
- if (floating_value < 0.0) {
- // Flipping all bits for negative values.
- return static_cast<U>(~tmp) << std::max(s, 0);
- } else {
- // Flipping only first bit.
- return (static_cast<U>(tmp) << std::max(s, 0)) ^ mask;
- }
-}
-
-template <typename U>
-U TupleRowZOrderComparator::get_shared_string_representation(const char*
char_ptr,
- int length) const
{
- int len = length < sizeof(U) ? length : sizeof(U);
- if (len == 0) return 0;
- U dst = 0;
- // We copy the bytes from the string but swap the bytes because of integer
endianness.
- BitUtil::ByteSwapScalar(&dst, char_ptr, len);
- return dst << ((sizeof(U) - len) * 8);
-}
-
-int TupleRowZOrderComparator::operator()(const char* lhs, const char* rhs)
const {
- int result = compare(lhs, rhs);
- return result;
-}
-
-int TupleRowZOrderComparator::get_type_byte_size(FieldType type) const {
- switch (type) {
- case FieldType::OLAP_FIELD_TYPE_OBJECT:
- case FieldType::OLAP_FIELD_TYPE_HLL:
- case FieldType::OLAP_FIELD_TYPE_STRUCT:
- case FieldType::OLAP_FIELD_TYPE_ARRAY:
- case FieldType::OLAP_FIELD_TYPE_MAP:
- case FieldType::OLAP_FIELD_TYPE_CHAR:
- case FieldType::OLAP_FIELD_TYPE_VARCHAR:
- return 0;
- case FieldType::OLAP_FIELD_TYPE_NONE:
- case FieldType::OLAP_FIELD_TYPE_BOOL:
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
- case FieldType::OLAP_FIELD_TYPE_TINYINT:
- return 1;
- case FieldType::OLAP_FIELD_TYPE_SMALLINT:
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
- return 2;
- case FieldType::OLAP_FIELD_TYPE_FLOAT:
- case FieldType::OLAP_FIELD_TYPE_INT:
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT:
- return 4;
- case FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
- case FieldType::OLAP_FIELD_TYPE_DOUBLE:
- case FieldType::OLAP_FIELD_TYPE_BIGINT:
- case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
- return 8;
- case FieldType::OLAP_FIELD_TYPE_DECIMAL:
- case FieldType::OLAP_FIELD_TYPE_LARGEINT:
- case FieldType::OLAP_FIELD_TYPE_DATETIME:
- case FieldType::OLAP_FIELD_TYPE_DATE:
- return 16;
- case FieldType::OLAP_FIELD_TYPE_UNKNOWN:
- DCHECK(false);
- break;
- default:
- DCHECK(false);
- }
- return -1;
-}
-
} // namespace doris
diff --git a/be/src/util/tuple_row_zorder_compare.h
b/be/src/util/tuple_row_zorder_compare.h
index 337345713e..db40ddc283 100644
--- a/be/src/util/tuple_row_zorder_compare.h
+++ b/be/src/util/tuple_row_zorder_compare.h
@@ -35,33 +35,4 @@ public:
virtual ~RowComparator() = default;
virtual int operator()(const char* left, const char* right) const;
};
-
-class TupleRowZOrderComparator : public RowComparator {
-private:
- typedef __uint128_t uint128_t;
- int _max_col_size = 0;
- const Schema* _schema;
- int _sort_col_num = 0;
-
-public:
- TupleRowZOrderComparator();
- TupleRowZOrderComparator(int sort_col_num);
- TupleRowZOrderComparator(Schema* schema, int sort_col_num);
- virtual ~TupleRowZOrderComparator() {}
- int compare(const char* lhs, const char* rhs) const;
- void max_col_size(const RowCursor& rc);
- int compare_row(const RowCursor& lhs, const RowCursor& rhs);
- template <typename U, typename LhsRowType>
- int compare_based_on_size(LhsRowType& lhs, LhsRowType& rhs) const;
- template <typename U>
- U get_shared_representation(const void* val, FieldType type) const;
- template <typename U, typename T>
- U get_shared_int_representation(const T val, U mask) const;
- template <typename U, typename T>
- U get_shared_float_representation(const void* val, U mask) const;
- template <typename U>
- U get_shared_string_representation(const char* char_ptr, int length) const;
- virtual int operator()(const char* lhs, const char* rhs) const;
- int get_type_byte_size(FieldType type) const;
-};
} // namespace doris
diff --git a/be/test/CMakeLists.txt b/be/test/CMakeLists.txt
index 3a93ebd9c7..426ec67fde 100644
--- a/be/test/CMakeLists.txt
+++ b/be/test/CMakeLists.txt
@@ -252,7 +252,6 @@ set(UTIL_TEST_FILES
util/sort_heap_test.cpp
util/counts_test.cpp
util/date_func_test.cpp
- util/tuple_row_zorder_compare_test.cpp
util/array_parser_test.cpp
util/quantile_state_test.cpp
util/hdfs_storage_backend_test.cpp
diff --git a/be/test/util/tuple_row_zorder_compare_test.cpp
b/be/test/util/tuple_row_zorder_compare_test.cpp
deleted file mode 100644
index 09cf821348..0000000000
--- a/be/test/util/tuple_row_zorder_compare_test.cpp
+++ /dev/null
@@ -1,1111 +0,0 @@
-// 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 "util/tuple_row_zorder_compare.h"
-
-#include <gtest/gtest.h>
-
-#include "common/logging.h"
-#include "exprs/expr.h"
-#include "exprs/expr_context.h"
-#include "olap/memtable.h"
-#include "olap/row.h"
-#include "olap/schema.h"
-#include "runtime/descriptors.h"
-#include "runtime/large_int_value.h"
-#include "runtime/raw_value.h"
-#include "runtime/tuple.h"
-#include "runtime/tuple_row.h"
-#include "util/json_util.h"
-
-namespace doris {
-class TupleRowZOrderCompareTest : public testing::Test {
-public:
- ObjectPool _agg_buffer_pool;
- std::unique_ptr<MemPool> _buffer_mem_pool;
-
- TupleRowZOrderCompareTest() { _buffer_mem_pool.reset(new MemPool()); }
-
- ~TupleRowZOrderCompareTest() = default;
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareInt8Test(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::TINYINT);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(int8_t) + 1 * i;
-
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int8_t) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_TINYINT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_TINYINT, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int8_t),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int8_t));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int8_t),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int8_t));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareInt16Test(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::SMALLINT);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(int16_t) + 1 * i;
-
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int16_t) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
-
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_SMALLINT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_SMALLINT, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int16_t),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int16_t));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int16_t),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int16_t));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareIntTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::INT);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(int32_t) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int32_t) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_INT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_INT, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int32_t),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int32_t));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int32_t),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int32_t));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareInt64Test(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::BIGINT);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(int64_t) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int64_t) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_BIGINT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_BIGINT, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int64_t),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int64_t));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int64_t),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int64_t));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareInt128Test(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::LARGEINT);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(int128_t) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int128_t) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_LARGEINT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_LARGEINT, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int128_t),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int128_t));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int128_t),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int128_t));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareFloatTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::FLOAT);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(float) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(float) + 1 * (i
- 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_FLOAT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_FLOAT, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(float),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(float));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(float),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(float));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareDoubleTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::DOUBLE);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(double) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(double) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
-
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_DOUBLE, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_DOUBLE, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(double),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(double));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(double),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(double));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareBoolTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::BOOLEAN);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(bool) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(bool) + 1 * (i
- 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_BOOL, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_BOOL, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(bool),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(bool));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(bool),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(bool));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareCharTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::VARCHAR);
- scalar_type.__set_len(65535);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(StringValue) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(StringValue) +
1 * (i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_VARCHAR, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_VARCHAR, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(StringValue),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(StringValue));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(StringValue),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(StringValue));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareDateTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::DATETIME);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(DateTimeValue) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(DateTimeValue)
+ 1 * (i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_DATETIME, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_DATETIME, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(DateTimeValue),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1, lval2);
- uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num *
sizeof(char) +
- col_num *
sizeof(DateTimeValue));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(DateTimeValue),
- _buffer_mem_pool.get());
- FillMem(rhs_tuple, 1, rval1, rval2);
- uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num *
sizeof(char) +
- col_num *
sizeof(DateTimeValue));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- template <typename T, bool IS_FIRST_SLOT_NULL = false>
- int CompareDecimalTest(T lval1, T lval2, T rval1, T rval2) {
- int col_num = 2;
- std::vector<SlotDescriptor> slot_descs;
- for (int i = 1; i <= col_num; i++) {
- TSlotDescriptor slot_desc;
- slot_desc.id = i;
- slot_desc.parent = 0;
- TTypeDesc type;
- {
- TTypeNode node;
- node.__set_type(TTypeNodeType::SCALAR);
- TScalarType scalar_type;
- scalar_type.__set_type(TPrimitiveType::type::DECIMALV2);
- scalar_type.__isset.precision = true;
- scalar_type.__isset.scale = true;
- scalar_type.__set_precision(-1);
- scalar_type.__set_scale(-1);
- node.__set_scalar_type(scalar_type);
- type.types.push_back(node);
- }
- slot_desc.slotType = type;
- slot_desc.columnPos = i;
- slot_desc.byteOffset = (i - 1) * sizeof(int128_t) + 1 * i;
- slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int128_t) + 1 *
(i - 1);
- slot_desc.nullIndicatorBit = 1;
- std::ostringstream ss;
- ss << "col_" << i;
- slot_desc.colName = ss.str();
- slot_desc.slotIdx = i;
- slot_desc.isMaterialized = true;
- slot_descs.emplace_back(slot_desc);
- }
-
- std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_DECIMAL, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE,
OLAP_FIELD_TYPE_DECIMAL, true);
-
- Schema schema = Schema(col_schemas, col_num);
- TupleRowZOrderComparator comparator(&schema, 2);
- Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int128_t),
- _buffer_mem_pool.get());
- if (IS_FIRST_SLOT_NULL) {
- lhs_tuple->set_null(NullIndicatorOffset(0, 1));
- }
- FillMem(lhs_tuple, 1, lval1.value(), lval2.value());
- uint8_t* lhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int128_t));
- ContiguousRow lhs_row(&schema, lhs_tuple_buf);
- tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row,
_buffer_mem_pool.get());
-
- Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num *
sizeof(int128_t),
- _buffer_mem_pool.get());
-
- FillMem(rhs_tuple, 1, rval1.value(), rval2.value());
- uint8_t* rhs_tuple_buf =
- _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num *
sizeof(int128_t));
- ContiguousRow rhs_row(&schema, rhs_tuple_buf);
- tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row,
_buffer_mem_pool.get());
- int result = comparator.compare(reinterpret_cast<const
char*>(lhs_row.row_ptr()),
- reinterpret_cast<const
char*>(rhs_row.row_ptr()));
- return result;
- }
-
- void tuple_to_row(const Schema& schema, const vector<SlotDescriptor>&
slot_descs,
- const Tuple* tuple, ContiguousRow* row, MemPool*
mem_pool) {
- for (size_t i = 0; i < slot_descs.size(); ++i) {
- auto cell = row->cell(i);
- const SlotDescriptor& slot = slot_descs[i];
- bool is_null = tuple->is_null(slot.null_indicator_offset());
- const void* value = tuple->get_slot(slot.tuple_offset());
- schema.column(i)->consume(&cell, (const char*)value, is_null,
mem_pool,
- &_agg_buffer_pool);
- }
- }
-
- template <typename T>
- void FillMem(Tuple* tuple_mem, int idx, T val) {
- memcpy(tuple_mem->get_slot(idx), &val, sizeof(T));
- }
-
- template <typename T, typename... Args>
- void FillMem(Tuple* tuple_mem, int idx, T val, Args... args) {
- // Use memcpy to avoid gcc generating unaligned instructions like
movaps
- // for int128_t. They will raise SegmentFault when addresses are not
- // aligned to 16 bytes.
- memcpy(tuple_mem->get_slot(idx), &val, sizeof(T));
- FillMem(tuple_mem, idx + sizeof(T) + 1, args...);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int Int8Int8Test(int8_t lval1, int8_t lval2, int8_t rval1, int8_t rval2) {
- return CompareInt8Test<int8_t, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int Int16Int16Test(int16_t lval1, int16_t lval2, int16_t rval1, int16_t
rval2) {
- return CompareInt16Test<int16_t, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int IntIntTest(int32_t lval1, int32_t lval2, int32_t rval1, int32_t rval2)
{
- return CompareIntTest<int32_t, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int Int64Int64Test(int64_t lval1, int64_t lval2, int64_t rval1, int64_t
rval2) {
- return CompareInt64Test<int64_t, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int Int128Int128Test(int128_t lval1, int128_t lval2, int128_t rval1,
int128_t rval2) {
- return CompareInt128Test<int128_t, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int FloatFloatTest(float lval1, float lval2, float rval1, float rval2) {
- return CompareFloatTest<float, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int DoubleDoubleTest(double lval1, double lval2, double rval1, double
rval2) {
- return CompareDoubleTest<double, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int BoolBoolTest(bool lval1, bool lval2, bool rval1, bool rval2) {
- return CompareBoolTest<bool, IS_FIRST_SLOT_NULL>(lval1, lval2, rval1,
rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int CharCharTest(StringValue lval1, StringValue lval2, StringValue rval1,
StringValue rval2) {
- return CompareCharTest<StringValue, IS_FIRST_SLOT_NULL>(lval1, lval2,
rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int DateDateTest(DateTimeValue lval1, DateTimeValue lval2, DateTimeValue
rval1,
- DateTimeValue rval2) {
- return CompareDateTest<DateTimeValue, IS_FIRST_SLOT_NULL>(lval1,
lval2, rval1, rval2);
- }
-
- template <bool IS_FIRST_SLOT_NULL = false>
- int DecimalDecimalTest(DecimalV2Value lval1, DecimalV2Value lval2,
DecimalV2Value rval1,
- DecimalV2Value rval2) {
- return CompareDecimalTest<DecimalV2Value, IS_FIRST_SLOT_NULL>(lval1,
lval2, rval1, rval2);
- }
-};
-
-TEST_F(TupleRowZOrderCompareTest, DecimalTest) {
- std::string str1 = "1.00";
- std::string str2 = "1.00";
- std::string str3 = "1.00";
- std::string str4 = "1.00";
- DecimalV2Value val1(str1);
- DecimalV2Value val2(str2);
- DecimalV2Value val3(str3);
- DecimalV2Value val4(str4);
- EXPECT_EQ(DecimalDecimalTest(val1, val2, val3, val4), 0);
- str1 = "-5.0";
- str2 = "3.0";
- str3 = "-5.0";
- str4 = "3.0";
- DecimalV2Value val5(str1);
- DecimalV2Value val6(str2);
- DecimalV2Value val7(str3);
- DecimalV2Value val8(str4);
- EXPECT_EQ(DecimalDecimalTest(val5, val6, val7, val8), 0);
- str1 = "1.0";
- str2 = "0.0";
- str3 = "0.0";
- str4 = "1.0";
- DecimalV2Value val9(str1);
- DecimalV2Value val10(str2);
- DecimalV2Value val11(str3);
- DecimalV2Value val12(str4);
- EXPECT_EQ(DecimalDecimalTest(val9, val10, val11, val12), 1);
- str1 = "0";
- str2 = "1";
- str3 = "1";
- str4 = "0";
- DecimalV2Value val13(str1);
- DecimalV2Value val14(str2);
- DecimalV2Value val15(str3);
- DecimalV2Value val16(str4);
- EXPECT_EQ(DecimalDecimalTest(val13, val14, val15, val16), -1);
- str1 = "256";
- str2 = "10";
- str3 = "255";
- str4 = "100";
- DecimalV2Value val17(str1);
- DecimalV2Value val18(str2);
- DecimalV2Value val19(str3);
- DecimalV2Value val20(str4);
- EXPECT_EQ(DecimalDecimalTest(val17, val18, val19, val20), -1);
- str1 = "3";
- str2 = "1024";
- str3 = "128";
- str4 = "1023";
- DecimalV2Value val21(str1);
- DecimalV2Value val22(str2);
- DecimalV2Value val23(str3);
- DecimalV2Value val24(str4);
- EXPECT_EQ(DecimalDecimalTest(val21, val22, val23, val24), -1);
- str1 = "1024";
- str2 = "511";
- str3 = "1023";
- str4 = "0";
- DecimalV2Value val25(str1);
- DecimalV2Value val26(str2);
- DecimalV2Value val27(str3);
- DecimalV2Value val28(str4);
- EXPECT_EQ(DecimalDecimalTest(val25, val26, val27, val28), 1);
- str1 = "5550";
- str2 = "0";
- str3 = "5000";
- str4 = "4097";
- DecimalV2Value val29(str1);
- DecimalV2Value val30(str2);
- DecimalV2Value val31(str3);
- DecimalV2Value val32(str4);
- EXPECT_EQ(DecimalDecimalTest(val29, val30, val31, val32), -1);
-}
-
-TEST_F(TupleRowZOrderCompareTest, DateDateTest) {
- DateTimeValue val1;
- DateTimeValue val2;
- DateTimeValue val3;
- DateTimeValue val4;
- std::string str1 = "2015-04-09 14:07:46";
- std::string str2 = "2015-04-09 14:07:46";
- std::string str3 = "2015-04-09 14:07:46";
- std::string str4 = "2015-04-09 14:07:46";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), 0);
- str1 = "1415-12-09 10:07:44";
- str2 = "2015-04-09 14:07:46";
- str3 = "1415-12-09 10:07:44";
- str4 = "2015-04-09 14:07:46";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), 0);
- str1 = "1400-01-01 00:00:00";
- str2 = "9999-12-31 14:07:46";
- str3 = "8000-12-09 10:07:44";
- str4 = "2015-04-09 14:07:46";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), -1);
- str1 = "1400-01-01 00:00:01";
- str2 = "1400-01-01 00:00:00";
- str3 = "1400-01-01 00:00:00";
- str4 = "1400-01-01 00:00:01";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), 1);
- str1 = "1400-01-01 00:00:03";
- str2 = "1400-01-01 00:00:07";
- str3 = "1400-01-01 00:00:04";
- str4 = "1400-01-01 00:00:00";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), -1);
- str1 = "1400-01-01 00:00:06";
- str2 = "1400-01-01 00:00:04";
- str3 = "1400-01-01 00:00:05";
- str4 = "1400-01-01 00:00:07";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), 1);
- str1 = "1400-01-01 00:00:05";
- str2 = "1400-01-01 00:00:05";
- str3 = "1400-01-01 00:00:06";
- str4 = "1400-01-01 00:00:04";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), -1);
- str1 = "1400-01-01 23:59:59";
- str2 = "1400-01-01 00:00:00";
- str3 = "1400-01-02 00:00:00";
- str4 = "1400-01-01 00:00:00";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), -1);
- str1 = "3541-11-03 23:59:59";
- str2 = "3541-11-03 00:00:00";
- str3 = "3541-11-04 00:00:00";
- str4 = "3541-11-03 00:00:00";
- val1.from_date_str(str1.c_str(), str1.size());
- val2.from_date_str(str2.c_str(), str2.size());
- val3.from_date_str(str3.c_str(), str3.size());
- val4.from_date_str(str4.c_str(), str4.size());
- EXPECT_EQ(DateDateTest(val1, val2, val3, val4), -1);
-}
-TEST_F(TupleRowZOrderCompareTest, CharTest) {
- EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("b"),
StringValue("a"), StringValue("b")),
- 0);
- EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("b"),
StringValue("a"), StringValue("b")),
- 0);
- EXPECT_EQ(CharCharTest(StringValue("h"), StringValue("0"),
StringValue("h"), StringValue("0")),
- 0);
- EXPECT_EQ(CharCharTest(StringValue("h"), StringValue("z"),
StringValue("z"), StringValue("h")),
- -1);
- EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("0"),
StringValue("h"), StringValue("0")),
- -1);
- EXPECT_EQ(CharCharTest(StringValue("!"), StringValue("{"),
StringValue("0"), StringValue("K")),
- 1);
- EXPECT_EQ(CharCharTest(StringValue("A"), StringValue("~"),
StringValue("B"), StringValue("Z")),
- 1);
- EXPECT_EQ(CharCharTest(StringValue("aaa"), StringValue("bbb"),
StringValue("aaa"),
- StringValue("bbb")),
- 0);
- EXPECT_EQ(CharCharTest(StringValue("abc"), StringValue("bbc"),
StringValue("abc"),
- StringValue("bbc")),
- 0);
- EXPECT_EQ(CharCharTest(StringValue("aah"), StringValue("aa0"),
StringValue("aah"),
- StringValue("aa0")),
- 0);
- EXPECT_EQ(CharCharTest(StringValue("aaa"), StringValue("aa0"),
StringValue("aah"),
- StringValue("aa0")),
- -1);
- EXPECT_EQ(CharCharTest(StringValue("aah"), StringValue("aaz"),
StringValue("aaz"),
- StringValue("aah")),
- -1);
- EXPECT_EQ(CharCharTest(StringValue("aa!"), StringValue("aa{"),
StringValue("aa0"),
- StringValue("aaK")),
- 1);
- EXPECT_EQ(CharCharTest(StringValue("aaA"), StringValue("aa~"),
StringValue("aaB"),
- StringValue("aaZ")),
- 1);
-}
-TEST_F(TupleRowZOrderCompareTest, BoolTest) {
- EXPECT_EQ(BoolBoolTest(true, false, true, false), 0);
- EXPECT_EQ(BoolBoolTest(false, true, false, true), 0);
- EXPECT_EQ(BoolBoolTest(true, true, true, false), 1);
- EXPECT_EQ(BoolBoolTest(false, true, true, true), -1);
- EXPECT_EQ(BoolBoolTest(false, true, false, false), 1);
- EXPECT_EQ(BoolBoolTest(false, false, false, true), -1);
- EXPECT_EQ(BoolBoolTest(true, false, false, false), 1);
-}
-TEST_F(TupleRowZOrderCompareTest, DoubleTest) {
- EXPECT_EQ(DoubleDoubleTest(1.0, 0.0, 0.0, 1.0f), 1);
- EXPECT_EQ(DoubleDoubleTest(0.0, 1.0, 1.0, 0.0f), -1);
- EXPECT_EQ(DoubleDoubleTest(4.0, 3.0, 3.0, 4.0), 1);
- EXPECT_EQ(DoubleDoubleTest(5.0, 7.0, 4.0, 10.0), -1);
- EXPECT_EQ(DoubleDoubleTest(6.0, 10.0, 7.0, 3.0), 1);
- EXPECT_EQ(DoubleDoubleTest(9.0, 7.0, 8.0, 10.0), -1);
- EXPECT_EQ(DoubleDoubleTest(8.0, 8.0, 9.0, 7.0), 1);
- EXPECT_EQ(DoubleDoubleTest(9.0, 4.0, 6.0, 10.0), 1);
- EXPECT_EQ(DoubleDoubleTest(-4.0, -3.0, -3.0, -4.0), -1);
- EXPECT_EQ(DoubleDoubleTest(-5.0, -7.0, -4.0, -10.0), 1);
- EXPECT_EQ(DoubleDoubleTest(-6.0, -10.0, -7.0, -3.0), -1);
- EXPECT_EQ(DoubleDoubleTest(-9.0, -7.0, -8.0, -10.0), 1);
- EXPECT_EQ(DoubleDoubleTest(-8.0, -8.0, -9.0, -7.0), -1);
- EXPECT_EQ(DoubleDoubleTest(-9.0, -4.0, -6.0, -10.0), -1);
- EXPECT_EQ(DoubleDoubleTest(DBL_MAX / 2.0 + 2.0, 1.0, 1.0, DBL_MAX), 1);
-}
-TEST_F(TupleRowZOrderCompareTest, FloatTest) {
- EXPECT_EQ(FloatFloatTest(1.0f, 0.0f, 0.0f, 1.0f), 1);
- EXPECT_EQ(FloatFloatTest(0.0f, 1.0f, 1.0f, 0.0f), -1);
- EXPECT_EQ(FloatFloatTest(4.0f, 3.0f, 3.0f, 4.0f), 1);
- EXPECT_EQ(FloatFloatTest(5.0f, 7.0f, 4.0f, 10.0f), -1);
- EXPECT_EQ(FloatFloatTest(6.0f, 10.0f, 7.0f, 3.0f), 1);
- EXPECT_EQ(FloatFloatTest(9.0f, 7.0f, 8.0f, 10.0f), -1);
- EXPECT_EQ(FloatFloatTest(8.0f, 8.0f, 9.0f, 7.0f), 1);
- EXPECT_EQ(FloatFloatTest(9.0f, 4.0f, 6.0f, 10.0f), 1);
- EXPECT_EQ(FloatFloatTest(-4.0f, -3.0f, -3.0f, -4.0f), -1);
- EXPECT_EQ(FloatFloatTest(-5.0f, -7.0f, -4.0f, -10.0f), 1);
- EXPECT_EQ(FloatFloatTest(-6.0f, -10.0f, -7.0f, -3.0f), -1);
- EXPECT_EQ(FloatFloatTest(-9.0f, -7.0f, -8.0f, -10.0f), 1);
- EXPECT_EQ(FloatFloatTest(-8.0f, -8.0f, -9.0f, -7.0f), -1);
- EXPECT_EQ(FloatFloatTest(-9.0f, -4.0f, -6.0f, -10.0f), -1);
- EXPECT_EQ(FloatFloatTest(FLT_MAX / 2.0f + 2.0f, 1.0f, 1.0f, FLT_MAX), 1);
-}
-TEST_F(TupleRowZOrderCompareTest, Int8Test) {
- EXPECT_EQ(Int8Int8Test(0, 0, 0, 0), 0);
- EXPECT_EQ(Int8Int8Test(-5, 3, -5, 3), 0);
- EXPECT_EQ(Int8Int8Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int8Int8Test(0, 1, 1, 0), -1);
- EXPECT_EQ(Int8Int8Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int8Int8Test(2, 4, 1, 7), 1);
- EXPECT_EQ(Int8Int8Test(3, 7, 4, 0), -1);
- EXPECT_EQ(Int8Int8Test(6, 4, 5, 7), 1);
- EXPECT_EQ(Int8Int8Test(5, 5, 6, 4), -1);
- EXPECT_EQ(Int8Int8Test(6, 1, 3, 7), 1);
- EXPECT_EQ(Int8Int8Test(INT8_MAX / 2 + 2, 1, 1, INT8_MAX), 1);
- EXPECT_EQ(Int8Int8Test(INT8_MAX / 2, 1, 1, INT8_MAX), -1);
-}
-TEST_F(TupleRowZOrderCompareTest, Int16Test) {
- EXPECT_EQ(Int16Int16Test(0, 0, 0, 0), 0);
- EXPECT_EQ(Int16Int16Test(-5, 3, -5, 3), 0);
- EXPECT_EQ(Int16Int16Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int16Int16Test(0, 1, 1, 0), -1);
- EXPECT_EQ(Int16Int16Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int16Int16Test(2, 4, 1, 7), 1);
- EXPECT_EQ(Int16Int16Test(3, 7, 4, 0), -1);
- EXPECT_EQ(Int16Int16Test(6, 4, 5, 7), 1);
- EXPECT_EQ(Int16Int16Test(5, 5, 6, 4), -1);
- EXPECT_EQ(Int16Int16Test(6, 1, 3, 7), 1);
- EXPECT_EQ(Int16Int16Test(INT16_MAX / 2 + 2, 1, 1, INT16_MAX), 1);
- EXPECT_EQ(Int16Int16Test(INT16_MAX / 2, 1, 1, INT16_MAX), -1);
-}
-
-TEST_F(TupleRowZOrderCompareTest, Int32Test) {
- EXPECT_EQ(IntIntTest(0, 2, 1, 1), 1);
- EXPECT_EQ(IntIntTest(-5, 3, -5, 3), 0);
-
- EXPECT_EQ(IntIntTest(0, 4, 1, 2), 1);
- EXPECT_EQ(IntIntTest(0, 1, 1, 0), -1);
-
- EXPECT_EQ(IntIntTest(1, 0, 0, 1), 1);
- EXPECT_EQ(IntIntTest(2, 4, 1, 7), 1);
- EXPECT_EQ(IntIntTest(3, 7, 4, 0), -1);
- EXPECT_EQ(IntIntTest(6, 4, 5, 7), 1);
- EXPECT_EQ(IntIntTest(5, 5, 6, 4), -1);
- EXPECT_EQ(IntIntTest(6, 1, 3, 7), 1);
-
- EXPECT_EQ(IntIntTest(INT32_MAX / 2 + 2, 1, 1, INT32_MAX), 1);
- EXPECT_EQ(IntIntTest(INT32_MAX / 2, 1, 1, INT32_MAX), -1);
-
- EXPECT_EQ(IntIntTest<true>(1, 1, 1, 1), -1);
- EXPECT_EQ(IntIntTest<true>(4242, 1, 1, 1), -1);
- EXPECT_EQ(IntIntTest<true>(1, 0, 0, 1), -1);
- EXPECT_EQ(IntIntTest<true>(1, 0, INT32_MIN, 0), 0);
-}
-
-TEST_F(TupleRowZOrderCompareTest, Int64Test) {
- EXPECT_EQ(Int64Int64Test(0, 0, 0, 0), 0);
- EXPECT_EQ(Int64Int64Test(-5, 3, -5, 3), 0);
- EXPECT_EQ(Int64Int64Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int64Int64Test(0, 1, 1, 0), -1);
- EXPECT_EQ(Int64Int64Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int64Int64Test(2, 4, 1, 7), 1);
- EXPECT_EQ(Int64Int64Test(3, 7, 4, 0), -1);
- EXPECT_EQ(Int64Int64Test(6, 4, 5, 7), 1);
- EXPECT_EQ(Int64Int64Test(5, 5, 6, 4), -1);
- EXPECT_EQ(Int64Int64Test(6, 1, 3, 7), 1);
- EXPECT_EQ(Int64Int64Test(INT64_MAX / 2 + 2, 1, 1, INT64_MAX), 1);
- EXPECT_EQ(Int64Int64Test(INT64_MAX / 2, 1, 1, INT64_MAX), -1);
-}
-TEST_F(TupleRowZOrderCompareTest, LargeIntTest) {
- EXPECT_EQ(Int128Int128Test(0, 0, 0, 0), 0);
- EXPECT_EQ(Int128Int128Test(-5, 3, -5, 3), 0);
- EXPECT_EQ(Int128Int128Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int128Int128Test(0, 1, 1, 0), -1);
- EXPECT_EQ(Int128Int128Test(1, 0, 0, 1), 1);
- EXPECT_EQ(Int128Int128Test(2, 4, 1, 7), 1);
- EXPECT_EQ(Int128Int128Test(3, 7, 4, 0), -1);
- EXPECT_EQ(Int128Int128Test(6, 4, 5, 7), 1);
- EXPECT_EQ(Int128Int128Test(5, 5, 6, 4), -1);
- EXPECT_EQ(Int128Int128Test(6, 1, 3, 7), 1);
- EXPECT_EQ(Int128Int128Test(MAX_INT128 / 2 + 2, 1, 1, MAX_INT128), 1);
- Int128Int128Test(MAX_INT128 / 2, 1, 1, MAX_INT128);
-}
-
-} // namespace doris
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
