database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity
Files
a71822a74dfdd8b41983b23924b7bc22867784fa
doris/be/src/olap/tablet_schema.cpp
Lightman a71822a74d [refactor]remove col_unique_id (#11025)
2022-07-20 16:35:14 +08:00

738 lines
25 KiB
C++
Raw Blame History

// 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 "olap/tablet_schema.h"
#include "gen_cpp/descriptors.pb.h"
#include "tablet_meta.h"
#include "vec/aggregate_functions/aggregate_function_reader.h"
#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
#include "vec/core/block.h"
#include "vec/data_types/data_type_factory.hpp"
namespace doris {
FieldType TabletColumn::get_field_type_by_string(const std::string& type_str) {
std::string upper_type_str = type_str;
std::transform(type_str.begin(), type_str.end(), upper_type_str.begin(), toupper);
FieldType type;
if (0 == upper_type_str.compare("TINYINT")) {
type = OLAP_FIELD_TYPE_TINYINT;
} else if (0 == upper_type_str.compare("SMALLINT")) {
type = OLAP_FIELD_TYPE_SMALLINT;
} else if (0 == upper_type_str.compare("INT")) {
type = OLAP_FIELD_TYPE_INT;
} else if (0 == upper_type_str.compare("BIGINT")) {
type = OLAP_FIELD_TYPE_BIGINT;
} else if (0 == upper_type_str.compare("LARGEINT")) {
type = OLAP_FIELD_TYPE_LARGEINT;
} else if (0 == upper_type_str.compare("UNSIGNED_TINYINT")) {
type = OLAP_FIELD_TYPE_UNSIGNED_TINYINT;
} else if (0 == upper_type_str.compare("UNSIGNED_SMALLINT")) {
type = OLAP_FIELD_TYPE_UNSIGNED_SMALLINT;
} else if (0 == upper_type_str.compare("UNSIGNED_INT")) {
type = OLAP_FIELD_TYPE_UNSIGNED_INT;
} else if (0 == upper_type_str.compare("UNSIGNED_BIGINT")) {
type = OLAP_FIELD_TYPE_UNSIGNED_BIGINT;
} else if (0 == upper_type_str.compare("FLOAT")) {
type = OLAP_FIELD_TYPE_FLOAT;
} else if (0 == upper_type_str.compare("DISCRETE_DOUBLE")) {
type = OLAP_FIELD_TYPE_DISCRETE_DOUBLE;
} else if (0 == upper_type_str.compare("DOUBLE")) {
type = OLAP_FIELD_TYPE_DOUBLE;
} else if (0 == upper_type_str.compare("CHAR")) {
type = OLAP_FIELD_TYPE_CHAR;
} else if (0 == upper_type_str.compare("DATE")) {
type = OLAP_FIELD_TYPE_DATE;
} else if (0 == upper_type_str.compare("DATEV2")) {
type = OLAP_FIELD_TYPE_DATEV2;
} else if (0 == upper_type_str.compare("DATETIME")) {
type = OLAP_FIELD_TYPE_DATETIME;
} else if (0 == upper_type_str.compare("DECIMAL32")) {
type = OLAP_FIELD_TYPE_DECIMAL32;
} else if (0 == upper_type_str.compare("DECIMAL64")) {
type = OLAP_FIELD_TYPE_DECIMAL64;
} else if (0 == upper_type_str.compare("DECIMAL128")) {
type = OLAP_FIELD_TYPE_DECIMAL128;
} else if (0 == upper_type_str.compare(0, 7, "DECIMAL")) {
type = OLAP_FIELD_TYPE_DECIMAL;
} else if (0 == upper_type_str.compare(0, 7, "VARCHAR")) {
type = OLAP_FIELD_TYPE_VARCHAR;
} else if (0 == upper_type_str.compare("STRING")) {
type = OLAP_FIELD_TYPE_STRING;
} else if (0 == upper_type_str.compare("BOOLEAN")) {
type = OLAP_FIELD_TYPE_BOOL;
} else if (0 == upper_type_str.compare(0, 3, "HLL")) {
type = OLAP_FIELD_TYPE_HLL;
} else if (0 == upper_type_str.compare("STRUCT")) {
type = OLAP_FIELD_TYPE_STRUCT;
} else if (0 == upper_type_str.compare("LIST")) {
type = OLAP_FIELD_TYPE_ARRAY;
} else if (0 == upper_type_str.compare("MAP")) {
type = OLAP_FIELD_TYPE_MAP;
} else if (0 == upper_type_str.compare("OBJECT")) {
type = OLAP_FIELD_TYPE_OBJECT;
} else if (0 == upper_type_str.compare("ARRAY")) {
type = OLAP_FIELD_TYPE_ARRAY;
} else if (0 == upper_type_str.compare("QUANTILE_STATE")) {
type = OLAP_FIELD_TYPE_QUANTILE_STATE;
} else {
LOG(WARNING) << "invalid type string. [type='" << type_str << "']";
type = OLAP_FIELD_TYPE_UNKNOWN;
}
return type;
}
FieldAggregationMethod TabletColumn::get_aggregation_type_by_string(const std::string& str) {
std::string upper_str = str;
std::transform(str.begin(), str.end(), upper_str.begin(), toupper);
FieldAggregationMethod aggregation_type;
if (0 == upper_str.compare("NONE")) {
aggregation_type = OLAP_FIELD_AGGREGATION_NONE;
} else if (0 == upper_str.compare("SUM")) {
aggregation_type = OLAP_FIELD_AGGREGATION_SUM;
} else if (0 == upper_str.compare("MIN")) {
aggregation_type = OLAP_FIELD_AGGREGATION_MIN;
} else if (0 == upper_str.compare("MAX")) {
aggregation_type = OLAP_FIELD_AGGREGATION_MAX;
} else if (0 == upper_str.compare("REPLACE")) {
aggregation_type = OLAP_FIELD_AGGREGATION_REPLACE;
} else if (0 == upper_str.compare("REPLACE_IF_NOT_NULL")) {
aggregation_type = OLAP_FIELD_AGGREGATION_REPLACE_IF_NOT_NULL;
} else if (0 == upper_str.compare("HLL_UNION")) {
aggregation_type = OLAP_FIELD_AGGREGATION_HLL_UNION;
} else if (0 == upper_str.compare("BITMAP_UNION")) {
aggregation_type = OLAP_FIELD_AGGREGATION_BITMAP_UNION;
} else if (0 == upper_str.compare("QUANTILE_UNION")) {
aggregation_type = OLAP_FIELD_AGGREGATION_QUANTILE_UNION;
} else {
LOG(WARNING) << "invalid aggregation type string. [aggregation='" << str << "']";
aggregation_type = OLAP_FIELD_AGGREGATION_UNKNOWN;
}
return aggregation_type;
}
std::string TabletColumn::get_string_by_field_type(FieldType type) {
switch (type) {
case OLAP_FIELD_TYPE_TINYINT:
return "TINYINT";
case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
return "UNSIGNED_TINYINT";
case OLAP_FIELD_TYPE_SMALLINT:
return "SMALLINT";
case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
return "UNSIGNED_SMALLINT";
case OLAP_FIELD_TYPE_INT:
return "INT";
case OLAP_FIELD_TYPE_UNSIGNED_INT:
return "UNSIGNED_INT";
case OLAP_FIELD_TYPE_BIGINT:
return "BIGINT";
case OLAP_FIELD_TYPE_LARGEINT:
return "LARGEINT";
case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
return "UNSIGNED_BIGINT";
case OLAP_FIELD_TYPE_FLOAT:
return "FLOAT";
case OLAP_FIELD_TYPE_DOUBLE:
return "DOUBLE";
case OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
return "DISCRETE_DOUBLE";
case OLAP_FIELD_TYPE_CHAR:
return "CHAR";
case OLAP_FIELD_TYPE_DATE:
return "DATE";
case OLAP_FIELD_TYPE_DATEV2:
return "DATEV2";
case OLAP_FIELD_TYPE_DATETIME:
return "DATETIME";
case OLAP_FIELD_TYPE_DECIMAL:
return "DECIMAL";
case OLAP_FIELD_TYPE_DECIMAL32:
return "DECIMAL32";
case OLAP_FIELD_TYPE_DECIMAL64:
return "DECIMAL64";
case OLAP_FIELD_TYPE_DECIMAL128:
return "DECIMAL128";
case OLAP_FIELD_TYPE_VARCHAR:
return "VARCHAR";
case OLAP_FIELD_TYPE_STRING:
return "STRING";
case OLAP_FIELD_TYPE_BOOL:
return "BOOLEAN";
case OLAP_FIELD_TYPE_HLL:
return "HLL";
case OLAP_FIELD_TYPE_STRUCT:
return "STRUCT";
case OLAP_FIELD_TYPE_ARRAY:
return "ARRAY";
case OLAP_FIELD_TYPE_MAP:
return "MAP";
case OLAP_FIELD_TYPE_OBJECT:
return "OBJECT";
case OLAP_FIELD_TYPE_QUANTILE_STATE:
return "QUANTILE_STATE";
default:
return "UNKNOWN";
}
}
std::string TabletColumn::get_string_by_aggregation_type(FieldAggregationMethod type) {
switch (type) {
case OLAP_FIELD_AGGREGATION_NONE:
return "NONE";
case OLAP_FIELD_AGGREGATION_SUM:
return "SUM";
case OLAP_FIELD_AGGREGATION_MIN:
return "MIN";
case OLAP_FIELD_AGGREGATION_MAX:
return "MAX";
case OLAP_FIELD_AGGREGATION_REPLACE:
return "REPLACE";
case OLAP_FIELD_AGGREGATION_REPLACE_IF_NOT_NULL:
return "REPLACE_IF_NOT_NULL";
case OLAP_FIELD_AGGREGATION_HLL_UNION:
return "HLL_UNION";
case OLAP_FIELD_AGGREGATION_BITMAP_UNION:
return "BITMAP_UNION";
case OLAP_FIELD_AGGREGATION_QUANTILE_UNION:
return "QUANTILE_UNION";
default:
return "UNKNOWN";
}
}
uint32_t TabletColumn::get_field_length_by_type(TPrimitiveType::type type, uint32_t string_length) {
switch (type) {
case TPrimitiveType::TINYINT:
case TPrimitiveType::BOOLEAN:
return 1;
case TPrimitiveType::SMALLINT:
return 2;
case TPrimitiveType::INT:
return 4;
case TPrimitiveType::BIGINT:
return 8;
case TPrimitiveType::LARGEINT:
return 16;
case TPrimitiveType::DATE:
return 3;
case TPrimitiveType::DATEV2:
return 4;
case TPrimitiveType::DATETIME:
return 8;
case TPrimitiveType::FLOAT:
return 4;
case TPrimitiveType::DOUBLE:
return 8;
case TPrimitiveType::QUANTILE_STATE:
case TPrimitiveType::OBJECT:
return 16;
case TPrimitiveType::CHAR:
return string_length;
case TPrimitiveType::VARCHAR:
case TPrimitiveType::HLL:
return string_length + sizeof(OLAP_VARCHAR_MAX_LENGTH);
case TPrimitiveType::STRING:
return string_length + sizeof(OLAP_STRING_MAX_LENGTH);
case TPrimitiveType::ARRAY:
return OLAP_ARRAY_MAX_LENGTH;
case TPrimitiveType::DECIMAL32:
return 4;
case TPrimitiveType::DECIMAL64:
return 8;
case TPrimitiveType::DECIMAL128:
return 16;
case TPrimitiveType::DECIMALV2:
return 12; // use 12 bytes in olap engine.
default:
LOG(WARNING) << "unknown field type. [type=" << type << "]";
return 0;
}
}
TabletColumn::TabletColumn() : _aggregation(OLAP_FIELD_AGGREGATION_NONE) {}
TabletColumn::TabletColumn(FieldAggregationMethod agg, FieldType type) {
_aggregation = agg;
_type = type;
}
TabletColumn::TabletColumn(FieldAggregationMethod agg, FieldType filed_type, bool is_nullable) {
_aggregation = agg;
_type = filed_type;
_length = get_scalar_type_info(filed_type)->size();
_is_nullable = is_nullable;
}
TabletColumn::TabletColumn(FieldAggregationMethod agg, FieldType filed_type, bool is_nullable,
int32_t unique_id, size_t length) {
_aggregation = agg;
_type = filed_type;
_is_nullable = is_nullable;
_unique_id = unique_id;
_length = length;
}
TabletColumn::TabletColumn(const ColumnPB& column) {
init_from_pb(column);
}
TabletColumn::TabletColumn(const TColumn& column) {
init_from_thrift(column);
}
void TabletColumn::init_from_thrift(const TColumn& tcolumn) {
ColumnPB column_pb;
TabletMeta::init_column_from_tcolumn(tcolumn.col_unique_id, tcolumn, &column_pb);
init_from_pb(column_pb);
}
void TabletColumn::init_from_pb(const ColumnPB& column) {
_unique_id = column.unique_id();
_col_name = column.name();
_type = TabletColumn::get_field_type_by_string(column.type());
_is_key = column.is_key();
_is_nullable = column.is_nullable();
_has_default_value = column.has_default_value();
if (_has_default_value) {
_default_value = column.default_value();
}
if (column.has_precision()) {
_is_decimal = true;
_precision = column.precision();
} else {
_is_decimal = false;
}
if (column.has_frac()) {
_frac = column.frac();
}
_length = column.length();
_index_length = column.index_length();
if (column.has_is_bf_column()) {
_is_bf_column = column.is_bf_column();
} else {
_is_bf_column = false;
}
if (column.has_has_bitmap_index()) {
_has_bitmap_index = column.has_bitmap_index();
} else {
_has_bitmap_index = false;
}
_has_referenced_column = column.has_referenced_column_id();
if (_has_referenced_column) {
_referenced_column_id = column.referenced_column_id();
}
if (column.has_aggregation()) {
_aggregation = get_aggregation_type_by_string(column.aggregation());
}
if (column.has_visible()) {
_visible = column.visible();
}
if (_type == FieldType::OLAP_FIELD_TYPE_ARRAY) {
DCHECK(column.children_columns_size() == 1) << "ARRAY type has more than 1 children types.";
TabletColumn child_column;
child_column.init_from_pb(column.children_columns(0));
add_sub_column(child_column);
}
}
void TabletColumn::to_schema_pb(ColumnPB* column) const {
column->set_unique_id(_unique_id);
column->set_name(_col_name);
column->set_type(get_string_by_field_type(_type));
column->set_is_key(_is_key);
column->set_is_nullable(_is_nullable);
if (_has_default_value) {
column->set_default_value(_default_value);
}
if (_is_decimal) {
column->set_precision(_precision);
column->set_frac(_frac);
}
column->set_length(_length);
column->set_index_length(_index_length);
if (_is_bf_column) {
column->set_is_bf_column(_is_bf_column);
}
column->set_aggregation(get_string_by_aggregation_type(_aggregation));
if (_has_referenced_column) {
column->set_referenced_column_id(_referenced_column_id);
}
if (_has_bitmap_index) {
column->set_has_bitmap_index(_has_bitmap_index);
}
column->set_visible(_visible);
if (_type == OLAP_FIELD_TYPE_ARRAY) {
DCHECK(_sub_columns.size() == 1) << "ARRAY type has more than 1 children types.";
ColumnPB* child = column->add_children_columns();
_sub_columns[0].to_schema_pb(child);
}
}
uint32_t TabletColumn::mem_size() const {
auto size = sizeof(TabletColumn);
size += _col_name.size();
if (_has_default_value) {
size += _default_value.size();
}
if (_has_referenced_column) {
size += _referenced_column.size();
}
for (auto& sub_column : _sub_columns) {
size += sub_column.mem_size();
}
return size;
}
void TabletColumn::add_sub_column(TabletColumn& sub_column) {
_sub_columns.push_back(sub_column);
sub_column._parent = this;
_sub_column_count += 1;
}
vectorized::AggregateFunctionPtr TabletColumn::get_aggregate_function(
vectorized::DataTypes argument_types, std::string suffix) const {
std::string agg_name = TabletColumn::get_string_by_aggregation_type(_aggregation) + suffix;
std::transform(agg_name.begin(), agg_name.end(), agg_name.begin(),
[](unsigned char c) { return std::tolower(c); });
return vectorized::AggregateFunctionSimpleFactory::instance().get(
agg_name, argument_types, {}, argument_types.back()->is_nullable());
}
void TabletSchema::append_column(TabletColumn column) {
if (column.is_key()) {
_num_key_columns++;
}
if (column.is_nullable()) {
_num_null_columns++;
}
_field_name_to_index[column.name()] = _num_columns;
_field_id_to_index[column.unique_id()] = _num_columns;
_cols.push_back(std::move(column));
_num_columns++;
}
void TabletSchema::clear_columns() {
_field_name_to_index.clear();
_field_id_to_index.clear();
_num_columns = 0;
_num_null_columns = 0;
_num_key_columns = 0;
_cols.clear();
}
void TabletSchema::init_from_pb(const TabletSchemaPB& schema) {
_keys_type = schema.keys_type();
_num_columns = 0;
_num_key_columns = 0;
_num_null_columns = 0;
_cols.clear();
_field_name_to_index.clear();
for (auto& column_pb : schema.column()) {
TabletColumn column;
column.init_from_pb(column_pb);
if (column.is_key()) {
_num_key_columns++;
}
if (column.is_nullable()) {
_num_null_columns++;
}
_field_name_to_index[column.name()] = _num_columns;
_field_id_to_index[column.unique_id()] = _num_columns;
_cols.emplace_back(std::move(column));
_num_columns++;
}
_num_short_key_columns = schema.num_short_key_columns();
_num_rows_per_row_block = schema.num_rows_per_row_block();
_compress_kind = schema.compress_kind();
_next_column_unique_id = schema.next_column_unique_id();
if (schema.has_bf_fpp()) {
_has_bf_fpp = true;
_bf_fpp = schema.bf_fpp();
} else {
_has_bf_fpp = false;
_bf_fpp = BLOOM_FILTER_DEFAULT_FPP;
}
_is_in_memory = schema.is_in_memory();
_delete_sign_idx = schema.delete_sign_idx();
_sequence_col_idx = schema.sequence_col_idx();
_sort_type = schema.sort_type();
_sort_col_num = schema.sort_col_num();
_compression_type = schema.compression_type();
_schema_version = schema.schema_version();
}
void TabletSchema::build_current_tablet_schema(int64_t index_id,
const POlapTableSchemaParam& ptable_schema_param,
const TabletSchema& ori_tablet_schema) {
// copy from ori_tablet_schema
_keys_type = ori_tablet_schema.keys_type();
_num_short_key_columns = ori_tablet_schema.num_short_key_columns();
_num_rows_per_row_block = ori_tablet_schema.num_rows_per_row_block();
_compress_kind = ori_tablet_schema.compress_kind();
// todo(yixiu): unique_id
_next_column_unique_id = ori_tablet_schema.next_column_unique_id();
_is_in_memory = ori_tablet_schema.is_in_memory();
_delete_sign_idx = ori_tablet_schema.delete_sign_idx();
_sequence_col_idx = ori_tablet_schema.sequence_col_idx();
_sort_type = ori_tablet_schema.sort_type();
_sort_col_num = ori_tablet_schema.sort_col_num();
// copy from table_schema_param
_num_columns = 0;
_num_key_columns = 0;
_num_null_columns = 0;
bool has_bf_columns = false;
_cols.clear();
_field_name_to_index.clear();
_field_id_to_index.clear();
for (const POlapTableIndexSchema& index : ptable_schema_param.indexes()) {
if (index.id() == index_id) {
for (auto& pcolumn : index.columns_desc()) {
TabletColumn column;
column.init_from_pb(pcolumn);
if (column.is_key()) {
_num_key_columns++;
}
if (column.is_nullable()) {
_num_null_columns++;
}
if (column.is_bf_column()) {
has_bf_columns = true;
}
_field_name_to_index[column.name()] = _num_columns;
_field_id_to_index[column.unique_id()] = _num_columns;
_cols.emplace_back(std::move(column));
_num_columns++;
}
break;
}
}
if (has_bf_columns) {
_has_bf_fpp = true;
_bf_fpp = ori_tablet_schema.bloom_filter_fpp();
} else {
_has_bf_fpp = false;
_bf_fpp = BLOOM_FILTER_DEFAULT_FPP;
}
_schema_version = ptable_schema_param.version();
}
void TabletSchema::to_schema_pb(TabletSchemaPB* tablet_schema_pb) const {
tablet_schema_pb->set_keys_type(_keys_type);
for (auto& col : _cols) {
ColumnPB* column = tablet_schema_pb->add_column();
col.to_schema_pb(column);
}
tablet_schema_pb->set_num_short_key_columns(_num_short_key_columns);
tablet_schema_pb->set_num_rows_per_row_block(_num_rows_per_row_block);
tablet_schema_pb->set_compress_kind(_compress_kind);
if (_has_bf_fpp) {
tablet_schema_pb->set_bf_fpp(_bf_fpp);
}
tablet_schema_pb->set_next_column_unique_id(_next_column_unique_id);
tablet_schema_pb->set_is_in_memory(_is_in_memory);
tablet_schema_pb->set_delete_sign_idx(_delete_sign_idx);
tablet_schema_pb->set_sequence_col_idx(_sequence_col_idx);
tablet_schema_pb->set_sort_type(_sort_type);
tablet_schema_pb->set_sort_col_num(_sort_col_num);
tablet_schema_pb->set_schema_version(_schema_version);
tablet_schema_pb->set_compression_type(_compression_type);
}
uint32_t TabletSchema::mem_size() const {
auto size = sizeof(TabletSchema);
for (auto& col : _cols) {
size += col.mem_size();
}
for (auto& pair : _field_name_to_index) {
size += pair.first.size();
size += sizeof(pair.second);
}
return size;
}
size_t TabletSchema::row_size() const {
size_t size = 0;
for (auto& column : _cols) {
size += column.length();
}
size += (_num_columns + 7) / 8;
return size;
}
int32_t TabletSchema::field_index(const std::string& field_name) const {
const auto& found = _field_name_to_index.find(field_name);
return (found == _field_name_to_index.end()) ? -1 : found->second;
}
int32_t TabletSchema::field_index(int32_t col_unique_id) const {
const auto& found = _field_id_to_index.find(col_unique_id);
return (found == _field_id_to_index.end()) ? -1 : found->second;
}
const std::vector<TabletColumn>& TabletSchema::columns() const {
return _cols;
}
const TabletColumn& TabletSchema::column(size_t ordinal) const {
DCHECK(ordinal < _num_columns) << "ordinal:" << ordinal << ", _num_columns:" << _num_columns;
return _cols[ordinal];
}
void TabletSchema::init_field_index_for_test() {
_field_name_to_index.clear();
for (int i = 0; i < _cols.size(); ++i) {
_field_name_to_index[_cols[i].name()] = i;
}
}
vectorized::Block TabletSchema::create_block(
const std::vector<uint32_t>& return_columns,
const std::unordered_set<uint32_t>* tablet_columns_need_convert_null) const {
vectorized::Block block;
for (int i = 0; i < return_columns.size(); ++i) {
const auto& col = _cols[return_columns[i]];
bool is_nullable = (tablet_columns_need_convert_null != nullptr &&
tablet_columns_need_convert_null->find(return_columns[i]) !=
tablet_columns_need_convert_null->end());
auto data_type = vectorized::DataTypeFactory::instance().create_data_type(col, is_nullable);
auto column = data_type->create_column();
block.insert({std::move(column), data_type, col.name()});
}
return block;
}
vectorized::Block TabletSchema::create_block() const {
vectorized::Block block;
for (const auto& col : _cols) {
auto data_type = vectorized::DataTypeFactory::instance().create_data_type(col);
block.insert({data_type->create_column(), data_type, col.name()});
}
return block;
}
bool operator==(const TabletColumn& a, const TabletColumn& b) {
if (a._unique_id != b._unique_id) return false;
if (a._col_name != b._col_name) return false;
if (a._type != b._type) return false;
if (a._is_key != b._is_key) return false;
if (a._aggregation != b._aggregation) return false;
if (a._is_nullable != b._is_nullable) return false;
if (a._has_default_value != b._has_default_value) return false;
if (a._has_default_value) {
if (a._default_value != b._default_value) return false;
}
if (a._is_decimal != b._is_decimal) return false;
if (a._is_decimal) {
if (a._precision != b._precision) return false;
if (a._frac != b._frac) return false;
}
if (a._length != b._length) return false;
if (a._index_length != b._index_length) return false;
if (a._is_bf_column != b._is_bf_column) return false;
if (a._has_referenced_column != b._has_referenced_column) return false;
if (a._has_referenced_column) {
if (a._referenced_column_id != b._referenced_column_id) return false;
if (a._referenced_column != b._referenced_column) return false;
}
if (a._has_bitmap_index != b._has_bitmap_index) return false;
return true;
}
bool operator!=(const TabletColumn& a, const TabletColumn& b) {
return !(a == b);
}
bool operator==(const TabletSchema& a, const TabletSchema& b) {
if (a._keys_type != b._keys_type) return false;
if (a._cols.size() != b._cols.size()) return false;
for (int i = 0; i < a._cols.size(); ++i) {
if (a._cols[i] != b._cols[i]) return false;
}
if (a._num_columns != b._num_columns) return false;
if (a._num_key_columns != b._num_key_columns) return false;
if (a._num_null_columns != b._num_null_columns) return false;
if (a._num_short_key_columns != b._num_short_key_columns) return false;
if (a._num_rows_per_row_block != b._num_rows_per_row_block) return false;
if (a._compress_kind != b._compress_kind) return false;
if (a._next_column_unique_id != b._next_column_unique_id) return false;
if (a._has_bf_fpp != b._has_bf_fpp) return false;
if (a._has_bf_fpp) {
if (std::abs(a._bf_fpp - b._bf_fpp) > 1e-6) return false;
}
if (a._is_in_memory != b._is_in_memory) return false;
if (a._delete_sign_idx != b._delete_sign_idx) return false;
return true;
}
bool operator!=(const TabletSchema& a, const TabletSchema& b) {
return !(a == b);
}
} // namespace doris
Reference in New Issue View Git Blame Copy Permalink