hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Fix sstable param init function parameters bug.

Browse Source
This commit is contained in:
godyangfight 2024-12-12 12:14:48 +00:00 committed by ob-robot
parent 317b7c456f
commit 85a29f18fc
12 changed files with 208 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h
View File

@ -593,13 +593,19 @@ void TestIndexBlockDataPrepare::close_builder_and_prepare_sstable(const int64_t
ASSERT_EQ(OB_SUCCESS, param.data_block_ids_.assign(res.data_block_ids_));
ASSERT_EQ(OB_SUCCESS, param.other_block_ids_.assign(res.other_block_ids_));
param.ddl_scn_.set_min();
param.filled_tx_scn_.set_min();
param.contain_uncommitted_row_ = false;
param.encrypt_id_ = res.encrypt_id_;
param.master_key_id_ = res.master_key_id_;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.filled_tx_scn_ = table_key.get_end_scn();
param.filled_tx_scn_ = table_key.is_major_sstable() ? SCN::min_scn() : table_key.get_end_scn();
param.tx_data_recycle_scn_.set_min();
param.sstable_logic_seq_ = 0;
param.column_group_cnt_ = 1;
param.full_column_cnt_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.co_base_snapshot_version_ = 0;
MEMCPY(param.encrypt_key_, res.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
if (merge_type_ == MAJOR_MERGE) {
OK(ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_, param.column_checksums_));
@ -1124,12 +1130,20 @@ void TestIndexBlockDataPrepare::prepare_partial_sstable(const int64_t column_cnt
param.nested_size_ = res.nested_size_;
param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param.ddl_scn_.convert_from_ts(ObTimeUtility::current_time());
param.filled_tx_scn_.set_min();
param.contain_uncommitted_row_ = false;
param.encrypt_id_ = res.encrypt_id_;
param.master_key_id_ = res.master_key_id_;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.filled_tx_scn_ = table_key.is_major_sstable() ? SCN::min_scn() : table_key.get_end_scn();
param.tx_data_recycle_scn_.set_min();
param.sstable_logic_seq_ = 0;
param.column_group_cnt_ = 1;
param.full_column_cnt_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.co_base_snapshot_version_ = 0;
ASSERT_EQ(OB_SUCCESS, param.data_block_ids_.assign(res.data_block_ids_));
ASSERT_EQ(OB_SUCCESS, param.other_block_ids_.assign(res.other_block_ids_));
if (param.table_key_.is_co_sstable() && param.column_group_cnt_ <= 1) {

12
mittest/mtlenv/storage/test_co_merge.cpp
View File

@ -140,10 +140,18 @@ void close_builder_and_prepare_sstable(
param.nested_offset_ = res.nested_offset_;
ASSERT_EQ(OB_SUCCESS, param.data_block_ids_.assign(res.data_block_ids_));
ASSERT_EQ(OB_SUCCESS, param.other_block_ids_.assign(res.other_block_ids_));
param.nested_size_ = res.nested_size_;
param.nested_offset_ = res.nested_offset_;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.tx_data_recycle_scn_.set_min();
param.sstable_logic_seq_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.full_column_cnt_ = 0;
param.is_co_table_without_cgs_ = false;
param.co_base_snapshot_version_ = 0;
param.ddl_scn_.set_min();
param.filled_tx_scn_ = table_key.is_major_sstable() ? SCN::min_scn() : table_key.get_end_scn();
if (is_major_merge_type(data_store_desc.get_merge_type())) {
ASSERT_EQ(OB_SUCCESS, ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_, param.column_checksums_));
}

8
mittest/mtlenv/storage/test_physical_copy_task.cpp
View File

@ -240,6 +240,7 @@ void TestSSTableMeta::TearDown()
void TestSSTableMeta::prepare_create_sstable_param()
{
param_.set_init_value_for_column_store_();
const int64_t multi_version_col_cnt = ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
param_.table_key_.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
param_.table_key_.tablet_id_ = tablet_id_;
@ -267,10 +268,17 @@ void TestSSTableMeta::prepare_create_sstable_param()
param_.occupy_size_ = 0;
param_.ddl_scn_.set_min();
param_.filled_tx_scn_.set_min();
param_.tx_data_recycle_scn_.set_min();
param_.original_size_ = 0;
param_.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param_.encrypt_id_ = 0;
param_.master_key_id_ = 0;
param_.recycle_version_ = 0;
param_.root_macro_seq_ = 0;
param_.row_count_ = 0;
param_.sstable_logic_seq_ = 0;
param_.nested_offset_ = 0;
param_.nested_size_ = 0;
ASSERT_EQ(OB_SUCCESS, ObSSTableMergeRes::fill_column_checksum_for_empty_major(param_.column_cnt_, param_.column_checksums_));
}

8
mittest/mtlenv/storage/test_shared_block_reader_writer.cpp
View File

@ -76,6 +76,7 @@ void TestSharedBlockRWriter::TearDown()
void TestSharedBlockRWriter::create_empty_sstable(ObSSTable &empty_sstable)
{
ObTabletCreateSSTableParam param;
param.set_init_value_for_column_store_();
param.encrypt_id_ = 0;
param.master_key_id_ = 0;
MEMSET(param.encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
@ -106,12 +107,19 @@ void TestSharedBlockRWriter::create_empty_sstable(ObSSTable &empty_sstable)
param.occupy_size_ = 0;
param.ddl_scn_.set_min();
param.filled_tx_scn_.set_min();
param.tx_data_recycle_scn_.set_min();
param.original_size_ = 0;
param.ddl_scn_.set_min();
param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param.column_cnt_ = 1;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.sstable_logic_seq_ = 0;
param.row_count_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.nested_size_ = 0;
param.nested_offset_ = 0;
OK(ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_, param.column_checksums_));
OK(empty_sstable.init(param, &allocator_));
}

25
src/storage/ddl/ob_tablet_ddl_kv.cpp
View File

@ -148,7 +148,7 @@ int ObDDLMemtable::init_sstable_param(
sstable_param.table_key_.table_type_ = ObITable::TableType::DDL_MEM_CG_SSTABLE;
sstable_param.rowkey_column_cnt_ = 0;
sstable_param.column_cnt_ = 1;
} else { // co sstable with all cg or rowkey cg
} else {
sstable_param.table_key_.table_type_ = ObITable::TableType::DDL_MEM_CO_SSTABLE;
sstable_param.rowkey_column_cnt_ = storage_schema.get_rowkey_column_num() + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
@ -196,9 +196,28 @@ int ObDDLMemtable::init_sstable_param(
sstable_param.use_old_macro_block_count_ = 0; // all new, no reuse
sstable_param.index_blocks_cnt_ = 0; // index macro block count, the index is in memory, so be 0.
sstable_param.other_block_ids_.reset(); // other blocks contains only index macro blocks now, so empty.
sstable_param.filled_tx_scn_ = table_key.get_end_scn();
sstable_param.filled_tx_scn_ = table_key.is_major_sstable() ? SCN::min_scn() : table_key.get_end_scn();
sstable_param.tx_data_recycle_scn_.set_min();
sstable_param.table_backup_flag_.reset();
sstable_param.table_shared_flag_.reset();
sstable_param.sstable_logic_seq_ = 0;
sstable_param.row_count_ = 0;
sstable_param.recycle_version_ = 0;
sstable_param.root_macro_seq_ = 0;
sstable_param.nested_size_ = 0;
sstable_param.nested_offset_ = 0;
sstable_param.data_blocks_cnt_ = 0;
sstable_param.micro_block_cnt_ = 0;
sstable_param.occupy_size_ = 0;
sstable_param.original_size_ = 0;
sstable_param.progressive_merge_round_ = 0;
sstable_param.progressive_merge_step_ = 0;
sstable_param.column_group_cnt_ = 1;
sstable_param.co_base_type_ = ObCOSSTableBaseType::INVALID_TYPE;
sstable_param.full_column_cnt_ = 0;
sstable_param.is_co_table_without_cgs_ = false;
sstable_param.co_base_snapshot_version_ = 0;
}
if (OB_SUCC(ret)) {
// set root block for data tree
if (OB_FAIL(sstable_param.root_block_addr_.set_mem_addr(0/*offset*/, root_block_size/*size*/))) {

12
src/storage/high_availability/ob_transfer_struct.cpp
View File

@ -671,10 +671,22 @@ int ObTXTransferUtils::build_empty_minor_sstable_param_(
param.occupy_size_ = 0;
param.ddl_scn_.set_min();
param.filled_tx_scn_ = end_scn;
param.tx_data_recycle_scn_.set_min();
param.original_size_ = 0;
param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.sstable_logic_seq_ = 0;
param.row_count_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.nested_offset_ = 0;
param.nested_size_ = 0;
param.column_group_cnt_ = 1;
param.co_base_type_ = ObCOSSTableBaseType::INVALID_TYPE;
param.full_column_cnt_ = 0;
param.is_co_table_without_cgs_ = false;
param.co_base_snapshot_version_ = 0;
if (!param.is_valid()) {
ret = OB_INVALID_ARGUMENT;

12
src/storage/tablet/ob_tablet_create_delete_helper.cpp
View File

@ -963,10 +963,21 @@ int ObTabletCreateDeleteHelper::build_create_sstable_param(
param.occupy_size_ = 0;
param.ddl_scn_.set_min();
param.filled_tx_scn_.set_min();
param.tx_data_recycle_scn_.set_min();
param.original_size_ = 0;
param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.sstable_logic_seq_ = 0;
param.row_count_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.nested_size_ = 0;
param.nested_offset_ = 0;
param.column_group_cnt_ = 1;
param.co_base_type_ = ObCOSSTableBaseType::INVALID_TYPE;
param.full_column_cnt_ = 0;
param.is_co_table_without_cgs_ = false;
param.co_base_snapshot_version_ = 0;
if (OB_FAIL(storage_schema.get_store_column_count(param.column_cnt_, true/*is_full*/))) {
LOG_WARN("fail to get stored col cnt of table schema", K(ret), K(storage_schema));
@ -976,7 +987,6 @@ int ObTabletCreateDeleteHelper::build_create_sstable_param(
LOG_WARN("fail to fill column checksum for empty major", K(ret), K(param));
}
}
return ret;
}

104
src/storage/tablet/ob_tablet_create_sstable_param.cpp
View File

@ -37,11 +37,11 @@ namespace storage
// but not limited to unittest, merge, ddl, shared_macro_block
ObTabletCreateSSTableParam::ObTabletCreateSSTableParam()
: table_key_(),
sstable_logic_seq_(0),
sstable_logic_seq_(-1),
schema_version_(-1),
create_snapshot_version_(0),
progressive_merge_round_(0),
progressive_merge_step_(0),
create_snapshot_version_(-1),
progressive_merge_round_(-1),
progressive_merge_step_(-1),
is_ready_for_read_(true),
table_mode_(),
index_type_(share::schema::ObIndexType::INDEX_TYPE_MAX),
@ -49,42 +49,42 @@ ObTabletCreateSSTableParam::ObTabletCreateSSTableParam()
root_block_data_(),
root_row_store_type_(common::ObRowStoreType::MAX_ROW_STORE),
latest_row_store_type_(common::ObRowStoreType::MAX_ROW_STORE),
data_index_tree_height_(0),
data_index_tree_height_(-1),
data_block_macro_meta_addr_(),
data_block_macro_meta_(),
index_blocks_cnt_(0),
data_blocks_cnt_(0),
micro_block_cnt_(0),
use_old_macro_block_count_(0),
row_count_(0),
column_group_cnt_(1),
index_blocks_cnt_(-1),
data_blocks_cnt_(-1),
micro_block_cnt_(-1),
use_old_macro_block_count_(-1),
row_count_(-1),
column_group_cnt_(0),
co_base_type_(ObCOSSTableBaseType::INVALID_TYPE),
rowkey_column_cnt_(0),
column_cnt_(0),
full_column_cnt_(0),
rowkey_column_cnt_(-1),
column_cnt_(-1),
full_column_cnt_(-1),
data_checksum_(0),
occupy_size_(0),
original_size_(0),
occupy_size_(-1),
original_size_(-1),
max_merged_trans_version_(0),
ddl_scn_(SCN::min_scn()),
filled_tx_scn_(SCN::min_scn()),
tx_data_recycle_scn_(SCN::min_scn()),
ddl_scn_(),
filled_tx_scn_(),
tx_data_recycle_scn_(),
is_co_table_without_cgs_(false),
contain_uncommitted_row_(false),
is_meta_root_(false),
compressor_type_(ObCompressorType::INVALID_COMPRESSOR),
encrypt_id_(0),
master_key_id_(0),
recycle_version_(0),
nested_offset_(0),
nested_size_(0),
root_macro_seq_(0),
recycle_version_(-1),
nested_offset_(-1),
nested_size_(-1),
root_macro_seq_(-1),
data_block_ids_(),
other_block_ids_(),
table_backup_flag_(),
table_shared_flag_(),
uncommitted_tx_id_(0),
co_base_snapshot_version_(0)
co_base_snapshot_version_(-1)
{
MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
}
@ -105,6 +105,8 @@ bool ObTabletCreateSSTableParam::is_valid() const
} else if (!(schema_version_ >= 0
&& sstable_logic_seq_ >= 0
&& create_snapshot_version_ >= 0
&& progressive_merge_round_ >= 0
&& progressive_merge_step_ >= 0
&& index_type_ < share::schema::ObIndexType::INDEX_TYPE_MAX
&& root_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
&& (latest_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
@ -125,6 +127,9 @@ bool ObTabletCreateSSTableParam::is_valid() const
&& original_size_ >= 0
&& recycle_version_ >= 0
&& root_macro_seq_ >= 0
&& co_base_snapshot_version_ >= 0
&& nested_offset_ >= 0
&& nested_size_ >= 0
&& co_base_snapshot_version_ >= 0)) {
ret = false;
LOG_WARN("invalid basic params", KPC(this)); // LOG_KVS arg number overflow
@ -204,6 +209,7 @@ int ObTabletCreateSSTableParam::init_for_small_sstable(const blocksstable::ObSST
const blocksstable::ObBlockInfo &block_info)
{
int ret = OB_SUCCESS;
set_init_value_for_column_store_();
const blocksstable::ObSSTableBasicMeta &basic_meta = sstable_meta.get_basic_meta();
filled_tx_scn_ = basic_meta.filled_tx_scn_;
tx_data_recycle_scn_ = basic_meta.tx_data_recycle_scn_;
@ -226,7 +232,11 @@ int ObTabletCreateSSTableParam::init_for_small_sstable(const blocksstable::ObSST
nested_offset_ = block_info.nested_offset_;
nested_size_ = block_info.nested_size_;
table_shared_flag_.reset();
if (OB_FAIL(inner_init_with_merge_res(res))) {
if (table_key_.is_column_store_sstable()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("small sstable do not support co sstable", K(ret), K(table_key));
} else if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to inner init with merge res", K(ret), K(res));
} else if (table_key_.is_major_sstable()) {
if (OB_FAIL(column_checksums_.assign(res.data_column_checksums_))) {
@ -250,6 +260,8 @@ int ObTabletCreateSSTableParam::init_for_merge(const compaction::ObBasicTabletMe
{
int ret = OB_SUCCESS;
const compaction::ObStaticMergeParam &static_param = ctx.static_param_;
set_init_value_for_column_store_();
if (OB_FAIL(static_param.schema_->get_stored_column_count_in_sstable(full_column_cnt_))) {
LOG_WARN("fail to get_stored_column_count_in_sstable", K(ret), KPC(cg_schema), K(res));
} else {
@ -313,6 +325,7 @@ int ObTabletCreateSSTableParam::init_for_merge(const compaction::ObBasicTabletMe
ddl_scn_.set_min();
table_shared_flag_.reset();
co_base_snapshot_version_ = ctx.static_param_.co_base_snapshot_version_;
tx_data_recycle_scn_.set_min();
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to init with merge res", K(ret), K(res.data_block_ids_));
@ -351,6 +364,8 @@ int ObTabletCreateSSTableParam::init_for_ddl(blocksstable::ObSSTableIndexBuilder
share::schema::ObIndexType index_type = storage_schema.get_index_type();
int64_t rowkey_column_cnt = storage_schema.get_rowkey_column_num() + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
common::ObRowStoreType row_store_type = storage_schema.get_row_store_type();
set_init_value_for_column_store_();
if (nullptr != first_ddl_sstable) {
blocksstable::ObSSTableMetaHandle meta_handle;
if (OB_FAIL(first_ddl_sstable->get_meta(meta_handle))) {
@ -430,6 +445,11 @@ int ObTabletCreateSSTableParam::init_for_ddl(blocksstable::ObSSTableIndexBuilder
nested_offset_ = res.nested_offset_;
table_shared_flag_.reset();
filled_tx_scn_ = table_key_.get_end_scn();
sstable_logic_seq_ = 0;
progressive_merge_round_ = 0;
progressive_merge_step_ = 0;
tx_data_recycle_scn_.set_min();
recycle_version_ = 0;
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to inner init with merge res", K(ret), K(res));
@ -512,6 +532,8 @@ int ObTabletCreateSSTableParam::init_for_ss_ddl(blocksstable::ObSSTableMergeRes
share::schema::ObIndexType index_type = storage_schema.get_index_type();
int64_t rowkey_column_cnt = storage_schema.get_rowkey_column_num() + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
common::ObRowStoreType row_store_type = storage_schema.get_row_store_type();
set_init_value_for_column_store_();
if (table_key.is_column_store_sstable()) {
if (table_key.is_normal_cg_sstable()) {
rowkey_column_cnt = 0;
@ -560,6 +582,13 @@ int ObTabletCreateSSTableParam::init_for_ss_ddl(blocksstable::ObSSTableMergeRes
nested_offset_ = res.nested_offset_;
table_shared_flag_.set_shared_sstable();
filled_tx_scn_ = table_key_.get_end_scn();
ddl_scn_.set_min();
sstable_logic_seq_ = 0;
progressive_merge_round_ = 0;
progressive_merge_step_ = 0;
tx_data_recycle_scn_.set_min();
recycle_version_ = 0;
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to inner init with merge res", K(ret), K(res));
} else if (table_key.is_co_sstable()) {
@ -601,6 +630,7 @@ int ObTabletCreateSSTableParam::init_for_ha(
const blocksstable::ObSSTableMergeRes &res)
{
int ret = OB_SUCCESS;
set_init_value_for_column_store_();
table_key_ = sstable_param.table_key_;
sstable_logic_seq_ = sstable_param.basic_meta_.sstable_logic_seq_;
@ -627,6 +657,7 @@ int ObTabletCreateSSTableParam::init_for_ha(
co_base_type_ = sstable_param.co_base_type_;
is_co_table_without_cgs_ = sstable_param.is_empty_cg_sstables_;
}
recycle_version_ = sstable_param.basic_meta_.recycle_version_;
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to inner init with merge res", K(ret), K(res));
} else if (OB_FAIL(column_checksums_.assign(sstable_param.column_checksums_))) {
@ -650,6 +681,8 @@ int ObTabletCreateSSTableParam::init_for_ha(
int ObTabletCreateSSTableParam::init_for_ha(const blocksstable::ObMigrationSSTableParam &sstable_param)
{
int ret = OB_SUCCESS;
set_init_value_for_column_store_();
table_key_ = sstable_param.table_key_;
sstable_logic_seq_ = sstable_param.basic_meta_.sstable_logic_seq_;
schema_version_ = sstable_param.basic_meta_.schema_version_;
@ -693,6 +726,10 @@ int ObTabletCreateSSTableParam::init_for_ha(const blocksstable::ObMigrationSSTab
full_column_cnt_ = sstable_param.full_column_cnt_;
co_base_type_ = sstable_param.co_base_type_;
}
data_index_tree_height_ = sstable_param.basic_meta_.data_index_tree_height_;
recycle_version_ = sstable_param.basic_meta_.recycle_version_;
nested_offset_ = 0;
nested_size_ = 0;
if (OB_FAIL(column_checksums_.assign(sstable_param.column_checksums_))) {
LOG_WARN("fail to assign column checksums", K(ret), K(sstable_param));
} else if (OB_FAIL(blocksstable::ObSSTableMetaCompactUtil::fix_filled_tx_scn_value_for_compact(table_key_, filled_tx_scn_))) {
@ -709,6 +746,8 @@ int ObTabletCreateSSTableParam::init_for_ha(const blocksstable::ObMigrationSSTab
int ObTabletCreateSSTableParam::init_for_remote(const blocksstable::ObMigrationSSTableParam &sstable_param)
{
int ret = OB_SUCCESS;
set_init_value_for_column_store_();
table_key_ = sstable_param.table_key_;
sstable_logic_seq_ = sstable_param.basic_meta_.sstable_logic_seq_;
schema_version_ = sstable_param.basic_meta_.schema_version_;
@ -757,6 +796,9 @@ int ObTabletCreateSSTableParam::init_for_remote(const blocksstable::ObMigrationS
co_base_type_ = sstable_param.co_base_type_;
is_co_table_without_cgs_ = sstable_param.is_empty_cg_sstables_;
}
recycle_version_ = sstable_param.basic_meta_.recycle_version_;
nested_offset_ = 0;
nested_size_ = 0;
MEMCPY(encrypt_key_, sstable_param.basic_meta_.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
if (OB_FAIL(column_checksums_.assign(sstable_param.column_checksums_))) {
LOG_WARN("fail to fill column checksum", K(ret), K(sstable_param));
@ -777,6 +819,7 @@ int ObTabletCreateSSTableParam::init_for_mds(
// TODO: @baichangmin.bcm check ctx valid for mds
// reference to merge info
int ret = OB_SUCCESS;
set_init_value_for_column_store_();
const compaction::ObStaticMergeParam &static_param = ctx.static_param_;
ObITable::TableKey table_key;
@ -801,6 +844,7 @@ int ObTabletCreateSSTableParam::init_for_mds(
create_snapshot_version_ = static_param.create_snapshot_version_;
progressive_merge_round_ = 0;
progressive_merge_step_ = 0;
full_column_cnt_ = 0;
column_cnt_ = res.data_column_cnt_;
co_base_snapshot_version_ = 0;
@ -814,6 +858,7 @@ int ObTabletCreateSSTableParam::init_for_mds(
nested_offset_ = res.nested_offset_;
ddl_scn_.set_min();
table_shared_flag_.reset();
tx_data_recycle_scn_.set_min();
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to init with merge res", K(ret), K(res.data_block_ids_));
@ -873,5 +918,14 @@ int ObTabletCreateSSTableParam::inner_init_with_shared_sstable(const blocksstabl
return ret;
}
void ObTabletCreateSSTableParam::set_init_value_for_column_store_()
{
column_group_cnt_ = 1;
co_base_type_ = ObCOSSTableBaseType::INVALID_TYPE;
full_column_cnt_ = 0;
is_co_table_without_cgs_ = false;
co_base_snapshot_version_ = 0;
}
} // namespace storage
} // namespace oceanbase

3
src/storage/tablet/ob_tablet_create_sstable_param.h
View File

@ -126,6 +126,8 @@ public:
K_(original_size),
K_(max_merged_trans_version),
K_(ddl_scn),
K_(filled_tx_scn),
K_(tx_data_recycle_scn),
K_(is_co_table_without_cgs),
K_(contain_uncommitted_row),
K_(is_meta_root),
@ -145,6 +147,7 @@ private:
static const int64_t DEFAULT_MACRO_BLOCK_CNT = 64;
int inner_init_with_merge_res(const blocksstable::ObSSTableMergeRes &res);
int inner_init_with_shared_sstable(const blocksstable::ObMigrationSSTableParam &migration_param);
void set_init_value_for_column_store_();
public:
ObITable::TableKey table_key_;
int16_t sstable_logic_seq_;

6
unittest/storage/blocksstable/ob_multi_version_sstable_test.h
View File

@ -505,6 +505,7 @@ void ObMultiVersionSSTableTest::prepare_data_end(
ASSERT_EQ(OB_SUCCESS, root_index_builder_->close(res));
ObTabletCreateSSTableParam param;
param.set_init_value_for_column_store_();
table_key_.table_type_ = table_type;
ASSERT_EQ(OB_SUCCESS, param.data_block_ids_.assign(res.data_block_ids_));
ASSERT_EQ(OB_SUCCESS, param.other_block_ids_.assign(res.other_block_ids_));
@ -543,6 +544,11 @@ void ObMultiVersionSSTableTest::prepare_data_end(
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.filled_tx_scn_ = table_key_.get_end_scn();
param.tx_data_recycle_scn_.set_min();
param.sstable_logic_seq_ = 0;
param.row_count_ = 0;
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
if (table_type == ObITable::MAJOR_SSTABLE) {
ASSERT_EQ(OB_SUCCESS, ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_, param.column_checksums_));
}

24
unittest/storage/blocksstable/test_sstable_meta.cpp
View File

@ -222,6 +222,7 @@ void TestSSTableMacroInfo::TearDown()
void TestSSTableMacroInfo::prepare_create_sstable_param()
{
param_.set_init_value_for_column_store_();
const int64_t multi_version_col_cnt = ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
param_.table_key_.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
param_.table_key_.tablet_id_ = tablet_id_;
@ -249,10 +250,17 @@ void TestSSTableMacroInfo::prepare_create_sstable_param()
param_.occupy_size_ = 0;
param_.ddl_scn_.set_min();
param_.filled_tx_scn_.set_min();
param_.tx_data_recycle_scn_.set_min();
param_.original_size_ = 0;
param_.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param_.encrypt_id_ = 0;
param_.master_key_id_ = 0;
param_.recycle_version_ = 0;
param_.root_macro_seq_ = 0;
param_.row_count_ = 0;
param_.sstable_logic_seq_ = 0;
param_.nested_offset_ = 0;
param_.nested_size_ = 0;
ASSERT_EQ(OB_SUCCESS, ObSSTableMergeRes::fill_column_checksum_for_empty_major(param_.column_cnt_, param_.column_checksums_));
}
@ -333,6 +341,7 @@ void TestSSTableMeta::construct_sstable(
void TestSSTableMeta::prepare_create_sstable_param()
{
param_.set_init_value_for_column_store_();
const int64_t multi_version_col_cnt = ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
param_.table_key_.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
param_.table_key_.tablet_id_ = tablet_id_;
@ -360,10 +369,17 @@ void TestSSTableMeta::prepare_create_sstable_param()
param_.occupy_size_ = 0;
param_.ddl_scn_.set_min();
param_.filled_tx_scn_.set_min();
param_.tx_data_recycle_scn_.set_min();
param_.original_size_ = 0;
param_.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param_.encrypt_id_ = 0;
param_.master_key_id_ = 0;
param_.recycle_version_ = 0;
param_.root_macro_seq_ = 0;
param_.row_count_ = 0;
param_.sstable_logic_seq_ = 0;
param_.nested_offset_ = 0;
param_.nested_size_ = 0;
ASSERT_EQ(OB_SUCCESS, ObSSTableMergeRes::fill_column_checksum_for_empty_major(param_.column_cnt_, param_.column_checksums_));
}
@ -987,6 +1003,7 @@ TEST_F(TestMigrationSSTableParam, test_migrate_sstable)
int ret = OB_SUCCESS;
ObArenaAllocator allocator;
ObTabletCreateSSTableParam src_sstable_param;
src_sstable_param.set_init_value_for_column_store_();
src_sstable_param.table_key_.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
src_sstable_param.table_key_.tablet_id_ = tablet_id_;
src_sstable_param.table_key_.version_range_.base_version_ = ObVersionRange::MIN_VERSION;
@ -1012,11 +1029,18 @@ TEST_F(TestMigrationSSTableParam, test_migrate_sstable)
src_sstable_param.occupy_size_ = 0;
src_sstable_param.ddl_scn_.set_min();
src_sstable_param.filled_tx_scn_.set_min();
src_sstable_param.tx_data_recycle_scn_.set_min();
src_sstable_param.original_size_ = 0;
src_sstable_param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
src_sstable_param.encrypt_id_ = 1234;
src_sstable_param.master_key_id_ = 5678;
src_sstable_param.table_shared_flag_.set_shared_sstable();
src_sstable_param.recycle_version_ = 0;
src_sstable_param.root_macro_seq_ = 0;
src_sstable_param.row_count_ = 0;
src_sstable_param.sstable_logic_seq_ = 0;
src_sstable_param.nested_offset_ = 0;
src_sstable_param.nested_size_ = 0;
ret = src_sstable_param.column_checksums_.push_back(2022);
ASSERT_EQ(OB_SUCCESS, ret);

8
unittest/storage/test_tablet_helper.h
View File

@ -64,6 +64,7 @@ inline void TestTabletHelper::prepare_sstable_param(
const share::schema::ObTableSchema &table_schema,
ObTabletCreateSSTableParam &param)
{
param.set_init_value_for_column_store_();
const int64_t multi_version_col_cnt = ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
param.table_key_.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
param.table_key_.tablet_id_ = tablet_id;
@ -91,12 +92,19 @@ inline void TestTabletHelper::prepare_sstable_param(
param.occupy_size_ = 0;
param.ddl_scn_.set_min();
param.filled_tx_scn_.set_min();
param.tx_data_recycle_scn_.set_min();
param.original_size_ = 0;
param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
param.encrypt_id_ = 0;
param.master_key_id_ = 0;
param.table_backup_flag_.reset();
param.table_shared_flag_.reset();
param.recycle_version_ = 0;
param.root_macro_seq_ = 0;
param.row_count_ = 0;
param.sstable_logic_seq_ = 0;
param.nested_offset_ = 0;
param.nested_size_ = 0;
}
inline int TestTabletHelper::create_tablet(