diff --git a/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h b/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h index 9a6322a59..c6a59112a 100644 --- a/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h +++ b/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h @@ -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) { diff --git a/mittest/mtlenv/storage/test_co_merge.cpp b/mittest/mtlenv/storage/test_co_merge.cpp index 7c3717178..432fe4739 100644 --- a/mittest/mtlenv/storage/test_co_merge.cpp +++ b/mittest/mtlenv/storage/test_co_merge.cpp @@ -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_)); } diff --git a/mittest/mtlenv/storage/test_physical_copy_task.cpp b/mittest/mtlenv/storage/test_physical_copy_task.cpp index ee7130507..b4dfd7336 100644 --- a/mittest/mtlenv/storage/test_physical_copy_task.cpp +++ b/mittest/mtlenv/storage/test_physical_copy_task.cpp @@ -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_)); } diff --git a/mittest/mtlenv/storage/test_shared_block_reader_writer.cpp b/mittest/mtlenv/storage/test_shared_block_reader_writer.cpp index c534b7c96..2167c4242 100644 --- a/mittest/mtlenv/storage/test_shared_block_reader_writer.cpp +++ b/mittest/mtlenv/storage/test_shared_block_reader_writer.cpp @@ -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_)); } diff --git a/src/storage/ddl/ob_tablet_ddl_kv.cpp b/src/storage/ddl/ob_tablet_ddl_kv.cpp index 6173db0a5..b52ecebbb 100644 --- a/src/storage/ddl/ob_tablet_ddl_kv.cpp +++ b/src/storage/ddl/ob_tablet_ddl_kv.cpp @@ -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*/))) { diff --git a/src/storage/high_availability/ob_transfer_struct.cpp b/src/storage/high_availability/ob_transfer_struct.cpp index 10eb6e188..e6b925bd6 100644 --- a/src/storage/high_availability/ob_transfer_struct.cpp +++ b/src/storage/high_availability/ob_transfer_struct.cpp @@ -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; diff --git a/src/storage/tablet/ob_tablet_create_delete_helper.cpp b/src/storage/tablet/ob_tablet_create_delete_helper.cpp index 9fe875ca8..bd52a1d19 100644 --- a/src/storage/tablet/ob_tablet_create_delete_helper.cpp +++ b/src/storage/tablet/ob_tablet_create_delete_helper.cpp @@ -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; } diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.cpp b/src/storage/tablet/ob_tablet_create_sstable_param.cpp index 9e40cb5dc..f59c8dcaf 100644 --- a/src/storage/tablet/ob_tablet_create_sstable_param.cpp +++ b/src/storage/tablet/ob_tablet_create_sstable_param.cpp @@ -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 diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.h b/src/storage/tablet/ob_tablet_create_sstable_param.h index 1d75ef6ef..3cd61d03d 100644 --- a/src/storage/tablet/ob_tablet_create_sstable_param.h +++ b/src/storage/tablet/ob_tablet_create_sstable_param.h @@ -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_; diff --git a/unittest/storage/blocksstable/ob_multi_version_sstable_test.h b/unittest/storage/blocksstable/ob_multi_version_sstable_test.h index b7b9a7084..b0660088c 100644 --- a/unittest/storage/blocksstable/ob_multi_version_sstable_test.h +++ b/unittest/storage/blocksstable/ob_multi_version_sstable_test.h @@ -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_)); } diff --git a/unittest/storage/blocksstable/test_sstable_meta.cpp b/unittest/storage/blocksstable/test_sstable_meta.cpp index e7e493b9e..56811e558 100644 --- a/unittest/storage/blocksstable/test_sstable_meta.cpp +++ b/unittest/storage/blocksstable/test_sstable_meta.cpp @@ -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); diff --git a/unittest/storage/test_tablet_helper.h b/unittest/storage/test_tablet_helper.h index 09530f30e..4f63bc834 100644 --- a/unittest/storage/test_tablet_helper.h +++ b/unittest/storage/test_tablet_helper.h @@ -64,6 +64,7 @@ inline void TestTabletHelper::prepare_sstable_param( const share::schema::ObTableSchema &table_schema, ObTabletCreateSSTableParam ¶m) { + 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(