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

revert version refactor

Browse Source
This commit is contained in:
obdev 2022-11-28 02:18:10 +00:00 committed by ob-robot
parent 3cdfb11aa5
commit bbec6aff49
14 changed files with 106 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/logservice/palf/scn.cpp
View File

@ -277,7 +277,8 @@ int SCN::convert_for_lsn_allocator(uint64_t scn_val)
int ret = OB_SUCCESS;
if (OB_UNLIKELY(OB_MAX_SCN_TS_NS < scn_val)) {
ret = OB_INVALID_ARGUMENT;
PALF_LOG(WARN, "invalid argument", K(scn_val), K(ret));
PALF_LOG(WARN, "invalid argument", K(scn_val), K(ret), K(lbt()));
// TODO(yaoying.yyy):remove lbt() later
} else {
val_ = scn_val;
}

4
src/observer/virtual_table/ob_all_virtual_tablet_info.cpp
View File

@ -189,11 +189,11 @@ int ObAllVirtualTabletInfo::process_curr_tenant(ObNewRow *&row)
break;
case OB_APP_MIN_COLUMN_ID + 8:
// snapshot_version
cur_row_.cells_[i].set_uint64(tablet_meta.snapshot_version_.get_val_for_inner_table_field());
cur_row_.cells_[i].set_uint64(tablet_meta.snapshot_version_);
break;
case OB_APP_MIN_COLUMN_ID + 9:
// multi_version_start
cur_row_.cells_[i].set_uint64(tablet_meta.multi_version_start_.get_val_for_inner_table_field());
cur_row_.cells_[i].set_uint64(tablet_meta.multi_version_start_);
break;
default:
ret = OB_ERR_UNEXPECTED;

4
src/storage/access/ob_single_merge.cpp
View File

@ -236,7 +236,7 @@ int ObSingleMerge::inner_get_next_row(ObDatumRow &row)
const int64_t read_snapshot_version = access_ctx_->trans_version_range_.snapshot_version_;
const bool enable_fuse_row_cache = access_ctx_->use_fuse_row_cache_ &&
access_param_->iter_param_.enable_fuse_row_cache(access_ctx_->query_flag_) &&
read_snapshot_version >= tablet_meta.snapshot_version_.get_val_for_gts();
read_snapshot_version >= tablet_meta.snapshot_version_;
bool need_update_fuse_cache = false;
access_ctx_->query_flag_.set_not_use_row_cache();
nop_pos_.reset();
@ -273,7 +273,7 @@ int ObSingleMerge::inner_get_next_row(ObDatumRow &row)
#endif
} else if (enable_fuse_row_cache) {
if (OB_FAIL(get_and_fuse_cache_row(read_snapshot_version,
tablet_meta.multi_version_start_.get_val_for_gts(),
tablet_meta.multi_version_start_,
full_row_,
final_result,
have_uncommited_row,

4
src/storage/high_availability/ob_ls_restore.cpp
View File

@ -2025,8 +2025,8 @@ int ObTabletGroupMetaRestoreTask::create_or_update_tablet_(
param.data_tablet_id_ = tablet_id;
param.clog_checkpoint_scn_.reset();
param.compat_mode_ = lib::Worker::get_compatibility_mode();
param.multi_version_start_.set_min();
param.snapshot_version_.set_min();
param.multi_version_start_ = 0;
param.snapshot_version_ = 0;
param.tx_data_.tablet_status_ = ObTabletStatus::NORMAL;
if (OB_FAIL(param.ha_status_.set_restore_status(restore_status))) {

4
src/storage/high_availability/ob_storage_ha_reader.cpp
View File

@ -1011,8 +1011,8 @@ int ObCopyTabletInfoObProducer::build_deleted_tablet_info_(
tablet_info.param_.start_scn_.set_base();
tablet_info.param_.clog_checkpoint_scn_.set_base();
tablet_info.param_.compat_mode_ = lib::Worker::get_compatibility_mode();
tablet_info.param_.multi_version_start_.set_min();
tablet_info.param_.snapshot_version_.set_min();
tablet_info.param_.multi_version_start_ = 0;
tablet_info.param_.snapshot_version_ = 0;
tablet_info.param_.tx_data_.tablet_status_ = ObTabletStatus::DELETING;
tablet_info.param_.tx_data_.tx_scn_ = palf::SCN::min_scn();

17
src/storage/ob_storage_schema_recorder.cpp
View File

@ -150,7 +150,7 @@ int ObStorageSchemaRecorder::init(
// schema log is barrier, there is no concurrency problem, no need to lock
int ObStorageSchemaRecorder::replay_schema_log(
const int64_t log_ts,
const palf::SCN &scn,
const char *buf,
const int64_t size,
int64_t &pos)
@ -164,11 +164,7 @@ int ObStorageSchemaRecorder::replay_schema_log(
int64_t table_version = OB_INVALID_VERSION;
ObArenaAllocator tmp_allocator;
ObStorageSchema replay_storage_schema;
// TODO: fix it
palf::SCN scn;
if (OB_FAIL(scn.convert_for_lsn_allocator(log_ts))) {
LOG_WARN("convert failed", K(log_ts), K(ret));
} else if (tablet_id_.is_special_merge_tablet()) {
if (tablet_id_.is_special_merge_tablet()) {
// do nothing
} else if (OB_FAIL(serialization::decode_i64(buf, size, pos, &table_version))) {
// table_version
@ -176,8 +172,8 @@ int ObStorageSchemaRecorder::replay_schema_log(
} else if (table_version <= ATOMIC_LOAD(&max_saved_table_version_)) {
LOG_INFO("skip schema log with smaller table version", K_(tablet_id), K(table_version),
K(max_saved_table_version_));
} else if (OB_FAIL(replay_get_tablet_handle(log_ts, tablet_handle_))) {
LOG_WARN("failed to get tablet handle", K(ret), K_(tablet_id), K(log_ts));
} else if (OB_FAIL(replay_get_tablet_handle(scn, tablet_handle_))) {
LOG_WARN("failed to get tablet handle", K(ret), K_(tablet_id), K(scn));
} else if (OB_FAIL(replay_storage_schema.deserialize(tmp_allocator, buf, size, pos))) {
LOG_WARN("fail to deserialize storage schema", K(ret), K_(tablet_id));
} else if (FALSE_IT(replay_storage_schema.set_sync_finish(true))) {
@ -314,15 +310,12 @@ int ObStorageSchemaRecorder::get_tablet_handle(ObTabletHandle &tablet_handle)
return ret;
}
int ObStorageSchemaRecorder::replay_get_tablet_handle(const int64_t log_ts, ObTabletHandle &tablet_handle)
int ObStorageSchemaRecorder::replay_get_tablet_handle(const palf::SCN &scn, ObTabletHandle &tablet_handle)
{
int ret = OB_SUCCESS;
ObLSHandle ls_handle;
palf::SCN scn;
if (OB_FAIL(MTL(ObLSService *)->get_ls(ls_id_, ls_handle, ObLSGetMod::STORAGE_MOD))) {
LOG_WARN("failed to get log stream", K(ret), K(ls_id_));
} else if (OB_FAIL(scn.convert_for_lsn_allocator(log_ts))) {
LOG_WARN("convert failed", K(log_ts), K(ret));
} else if (OB_FAIL(ls_handle.get_ls()->replay_get_tablet(tablet_id_, scn, tablet_handle))) {
LOG_WARN("failed to get tablet", K(ret), K_(ls_id), K_(tablet_id), K(scn));
}

4
src/storage/ob_storage_schema_recorder.h
View File

@ -61,7 +61,7 @@ public:
void reset();
// follower
int replay_schema_log(const int64_t log_ts, const char *buf, const int64_t size, int64_t &pos);
int replay_schema_log(const palf::SCN &scn, const char *buf, const int64_t size, int64_t &pos);
// leader
int try_update_storage_schema(
const int64_t table_id,
@ -109,7 +109,7 @@ private:
void free_allocated_info();
int try_update_with_lock(const int64_t table_id, const int64_t table_version, const int64_t expire_ts);
int get_tablet_handle(ObTabletHandle &tablet_handle);
int replay_get_tablet_handle(const int64_t log_ts, ObTabletHandle &tablet_handle);
int replay_get_tablet_handle(const palf::SCN &scn, ObTabletHandle &tablet_handle);
// clog callback
void update_table_schema_fail();
void update_table_schema_succ(const int64_t table_version, bool &finish_flag);

58
src/storage/tablet/ob_tablet.cpp
View File

@ -152,7 +152,7 @@ int ObTablet::init(
LOG_WARN("failed to init shared params", K(ret), K(ls_id), K(tablet_id), KP(freezer));
} else if (OB_FAIL(tablet_meta_.init(*allocator_, ls_id, tablet_id, data_tablet_id,
lob_meta_tablet_id, lob_piece_tablet_id,
create_scn, snapshot_version, compat_mode, store_flag, table_schema.get_schema_version()))) {
create_scn, snapshot_version.get_val_for_tx(), compat_mode, store_flag, table_schema.get_schema_version()))) {
LOG_WARN("failed to init tablet meta", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
K(lob_meta_tablet_id), K(lob_piece_tablet_id),
K(create_scn), K(snapshot_version), K(compat_mode), K(store_flag));
@ -201,8 +201,8 @@ int ObTablet::init(
SCN snapshot_scn;
if (OB_FAIL(scn.convert_tmp(create_scn))) {
LOG_WARN("failed to convert_tmp", K(ret), K(create_scn));
} else if (OB_FAIL(snapshot_scn.convert_tmp(snapshot_version))) {
LOG_WARN("failed to convert_tmp", K(ret), K(snapshot_version));
} else if (OB_FAIL(snapshot_scn.convert_for_lsn_allocator(snapshot_version))) {
LOG_WARN("failed to convert scn", K(ret), K(snapshot_version));
} else if (OB_FAIL(init(ls_id, tablet_id, data_tablet_id, lob_meta_tablet_id, lob_piece_tablet_id,
scn, snapshot_scn, table_schema, compat_mode, store_flag, table_handle, freezer))) {
LOG_WARN("failed to init tablet", K(ret), K(scn));
@ -636,6 +636,24 @@ int ObTablet::load_deserialize(
return ret;
}
int ObTablet::get_multi_version_start(SCN &scn) const
{
int ret = OB_SUCCESS;
if (OB_FAIL(scn.convert_for_tx(tablet_meta_.multi_version_start_))) {
LOG_WARN("fail to convert scn", K(ret), K(tablet_meta_.multi_version_start_));
}
return ret;
}
int ObTablet::get_snapshot_version(SCN &scn) const
{
int ret = OB_SUCCESS;
if (OB_FAIL(scn.convert_for_tx(tablet_meta_.snapshot_version_))) {
LOG_WARN("fail to convert scn", K(ret), K(tablet_meta_.snapshot_version_));
}
return ret;
}
int64_t ObTablet::get_serialize_size() const
{
int64_t size = get_self_size();
@ -1503,36 +1521,6 @@ int ObTablet::assign_pointer_handle(const ObTabletPointerHandle &ptr_hdl)
return ret;
}
int ObTablet::replay_update_storage_schema(
const int64_t log_ts,
const char *buf,
const int64_t buf_size,
int64_t &pos)
{
int ret = OB_SUCCESS;
int64_t new_pos = pos;
ObIMemtableMgr *memtable_mgr = nullptr;
ObTabletMemtableMgr *data_memtable_mgr = nullptr;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
// do nothing
} else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
LOG_WARN("failed to get memtable mgr", K(ret));
} else if (FALSE_IT(data_memtable_mgr = static_cast<ObTabletMemtableMgr *>(memtable_mgr))) {
} else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(log_ts, buf, buf_size, new_pos))) {
LOG_WARN("storage schema recorder replay fail", K(ret), K(log_ts));
} else {
pos = new_pos;
}
if (OB_TIMEOUT == ret) {
ret = OB_EAGAIN; // need retry.
}
return ret;
}
int ObTablet::replay_update_storage_schema(
const palf::SCN &scn,
const char *buf,
@ -1552,7 +1540,7 @@ int ObTablet::replay_update_storage_schema(
} else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
LOG_WARN("failed to get memtable mgr", K(ret));
} else if (FALSE_IT(data_memtable_mgr = static_cast<ObTabletMemtableMgr *>(memtable_mgr))) {
} else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(scn.get_val_for_gts(), buf, buf_size, new_pos))) {
} else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(scn, buf, buf_size, new_pos))) {
LOG_WARN("storage schema recorder replay fail", K(ret), K(scn));
} else {
pos = new_pos;
@ -2364,7 +2352,7 @@ int ObTablet::start_ddl_if_need()
table_key.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
table_key.tablet_id_ = tablet_meta_.tablet_id_;
table_key.version_range_.base_version_ = 0;
table_key.version_range_.snapshot_version_ = tablet_meta_.ddl_snapshot_version_.get_val_for_gts();
table_key.version_range_.snapshot_version_ = tablet_meta_.ddl_snapshot_version_;
const SCN start_scn = tablet_meta_.ddl_start_scn_;
if (OB_FAIL(ddl_kv_mgr->ddl_start(table_key, start_scn.get_val_for_gts(), GET_MIN_CLUSTER_VERSION(), tablet_meta_.ddl_checkpoint_scn_.get_val_for_gts()))) {
LOG_WARN("start ddl kv manager failed", K(ret), K(table_key), K(start_scn));

11
src/storage/tablet/ob_tablet.h
View File

@ -327,8 +327,10 @@ public:
const ObTabletTableStore &get_table_store() const { return table_store_; }
int64_t get_clog_checkpoint_ts() const { return tablet_meta_.clog_checkpoint_scn_.get_val_for_gts(); }
palf::SCN get_clog_checkpoint_scn() const { return tablet_meta_.clog_checkpoint_scn_; }
int64_t get_snapshot_version() const { return tablet_meta_.snapshot_version_.get_val_for_gts(); }
int64_t get_multi_version_start() const { return tablet_meta_.multi_version_start_.get_val_for_gts(); }
int64_t get_snapshot_version() const { return tablet_meta_.snapshot_version_; }
int64_t get_multi_version_start() const { return tablet_meta_.multi_version_start_; }
int get_multi_version_start(palf::SCN &scn) const;
int get_snapshot_version(palf::SCN &scn) const;
// deprecated later, DO NOT use it!
ObTabletTableStore &get_table_store() { return table_store_; }
@ -344,11 +346,6 @@ public:
int assign_pointer_handle(const ObTabletPointerHandle &ptr_hdl);
int replay_update_storage_schema(
const int64_t log_ts,
const char *buf,
const int64_t buf_size,
int64_t &pos);
int replay_update_storage_schema(
const palf::SCN &scn,
const char *buf,

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

@ -2255,7 +2255,6 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
int ret = OB_SUCCESS;
ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
SCN snapshot_version;
snapshot_version.convert_tmp(arg.frozen_timestamp_);
const ObLSID &ls_id = arg.id_;
const ObTabletMapKey key(ls_id, tablet_id);
ObTablet *tablet = nullptr;
@ -2271,7 +2270,9 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
ObMetaDiskAddr mem_addr;
ObTabletTableStoreFlag table_store_flag;
table_store_flag.set_with_major_sstable();
if (OB_FAIL(mem_addr.set_mem_addr(0, sizeof(ObTablet)))) {
if (OB_FAIL(snapshot_version.convert_tmp(arg.frozen_timestamp_))) {
LOG_WARN("fail to convert scn", K(ret), K(arg.frozen_timestamp_));
} else if (OB_FAIL(mem_addr.set_mem_addr(0, sizeof(ObTablet)))) {
LOG_WARN("fail to set memory address", K(ret));
} else if (OB_FAIL(acquire_tablet(key, tablet_handle, false/*only acquire*/))) {
LOG_WARN("failed to acquire tablet", K(ret), K(key));

92
src/storage/tablet/ob_tablet_meta.cpp
View File

@ -40,8 +40,8 @@ ObTabletMeta::ObTabletMeta()
start_scn_(),
clog_checkpoint_scn_(),
ddl_checkpoint_scn_(),
snapshot_version_(),
multi_version_start_(),
snapshot_version_(OB_INVALID_TIMESTAMP),
multi_version_start_(OB_INVALID_TIMESTAMP),
compat_mode_(lib::Worker::CompatMode::INVALID),
autoinc_seq_(),
ha_status_(),
@ -50,7 +50,7 @@ ObTabletMeta::ObTabletMeta()
ddl_data_(),
table_store_flag_(),
ddl_start_scn_(),
ddl_snapshot_version_(),
ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
max_sync_storage_schema_version_(0),
is_inited_(false)
{
@ -100,11 +100,11 @@ int ObTabletMeta::init(
clog_checkpoint_scn_.set_base();
ddl_checkpoint_scn_.set_base();
compat_mode_ = compat_mode;
snapshot_version_.convert_tmp(snapshot_version);
multi_version_start_.convert_tmp(snapshot_version);
snapshot_version_ = snapshot_version;
multi_version_start_ = snapshot_version;
table_store_flag_ = table_store_flag;
ddl_start_scn_.set_min();
ddl_snapshot_version_.set_min();
ddl_snapshot_version_ = 0;
max_sync_storage_schema_version_ = max_sync_storage_schema_version;
report_status_.merge_snapshot_version_ = snapshot_version;
@ -136,7 +136,7 @@ int ObTabletMeta::init(
const common::ObTabletID &lob_meta_tablet_id,
const common::ObTabletID &lob_piece_tablet_id,
const palf::SCN create_scn,
const palf::SCN snapshot_version,
const int64_t snapshot_version,
const lib::Worker::CompatMode compat_mode,
const ObTabletTableStoreFlag &table_store_flag,
const int64_t max_sync_storage_schema_version)
@ -151,7 +151,7 @@ int ObTabletMeta::init(
|| OB_UNLIKELY(!data_tablet_id.is_valid())
// TODO: fix it after multi source data refactor
// || OB_UNLIKELY(!create_scn.is_valid())
|| OB_UNLIKELY(!snapshot_version.is_valid())
|| OB_UNLIKELY(OB_INVALID_TIMESTAMP == snapshot_version)
|| OB_UNLIKELY(lib::Worker::CompatMode::INVALID == compat_mode)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
@ -172,11 +172,11 @@ int ObTabletMeta::init(
multi_version_start_ = snapshot_version;
table_store_flag_ = table_store_flag;
ddl_start_scn_.set_min();
ddl_snapshot_version_.set_min();
ddl_snapshot_version_ = 0;
max_sync_storage_schema_version_ = max_sync_storage_schema_version;
report_status_.merge_snapshot_version_ = snapshot_version.get_val_for_gts();
report_status_.cur_report_version_ = snapshot_version.get_val_for_gts();
report_status_.merge_snapshot_version_ = snapshot_version;
report_status_.cur_report_version_ = snapshot_version;
report_status_.data_checksum_ = 0;
report_status_.row_count_ = 0;
@ -239,12 +239,12 @@ int ObTabletMeta::init(
compat_mode_ = old_tablet_meta.compat_mode_;
ha_status_ = old_tablet_meta.ha_status_;
report_status_ = old_tablet_meta.report_status_;
snapshot_version_.convert_tmp(MAX(snapshot_version, old_tablet_meta.snapshot_version_.get_val_for_gts()));
multi_version_start_.convert_tmp(MIN(MAX(multi_version_start, old_tablet_meta.multi_version_start_.get_val_for_gts()), snapshot_version_.get_val_for_gts()));
snapshot_version_ = MAX(snapshot_version, old_tablet_meta.snapshot_version_);
multi_version_start_ = MIN(MAX(multi_version_start, old_tablet_meta.multi_version_start_), snapshot_version_);
tx_data_ = tx_data;
table_store_flag_ = old_tablet_meta.table_store_flag_;
max_sync_storage_schema_version_ = max_sync_storage_schema_version;
ddl_snapshot_version_.convert_tmp(MAX(old_tablet_meta.ddl_snapshot_version_.get_val_for_gts(), ddl_snapshot_version));
ddl_snapshot_version_ = MAX(old_tablet_meta.ddl_snapshot_version_, ddl_snapshot_version);
is_inited_ = true;
}
@ -257,8 +257,8 @@ int ObTabletMeta::init(
int ObTabletMeta::init(
common::ObIAllocator &allocator,
const ObTabletMeta &old_tablet_meta,
const palf::SCN &snapshot_version,
const palf::SCN multi_version_start,
const int64_t snapshot_version,
const int64_t multi_version_start,
const ObTabletTxMultiSourceDataUnit &tx_data,
const ObTabletBindingInfo &ddl_data,
const ObTabletAutoincSeq &autoinc_seq,
@ -266,7 +266,7 @@ int ObTabletMeta::init(
const palf::SCN clog_checkpoint_scn,
const palf::SCN ddl_checkpoint_scn,
const palf::SCN ddl_start_scn,
const palf::SCN ddl_snapshot_version)
const int64_t ddl_snapshot_version)
{
int ret = OB_SUCCESS;
@ -367,8 +367,8 @@ void ObTabletMeta::reset()
start_scn_.reset();
clog_checkpoint_scn_.reset();
ddl_checkpoint_scn_ .reset();
snapshot_version_.reset();
multi_version_start_.reset();
snapshot_version_ = OB_INVALID_TIMESTAMP;
multi_version_start_ = OB_INVALID_TIMESTAMP;
compat_mode_ = lib::Worker::CompatMode::INVALID;
autoinc_seq_.reset();
ha_status_.reset();
@ -377,7 +377,7 @@ void ObTabletMeta::reset()
ddl_data_.reset();
table_store_flag_.reset();
ddl_start_scn_.reset();
ddl_snapshot_version_.reset();
ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
max_sync_storage_schema_version_ = 0;
is_inited_ = false;
}
@ -389,7 +389,7 @@ bool ObTabletMeta::is_valid() const
&& tablet_id_.is_valid()
&& data_tablet_id_.is_valid()
//&& create_scn_ > OB_INVALID_TIMESTAMP
&& multi_version_start_ >= SCN::min_scn()
&& multi_version_start_ >= 0
&& multi_version_start_ <= snapshot_version_
&& compat_mode_ != lib::Worker::CompatMode::INVALID
&& max_sync_storage_schema_version_ >= 0
@ -447,9 +447,9 @@ int ObTabletMeta::serialize(char *buf, const int64_t len, int64_t &pos)
LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(clog_checkpoint_scn));
} else if (new_pos - pos < length_ && OB_FAIL(ddl_checkpoint_scn_.fixed_serialize(buf, len, new_pos))) {
LOG_WARN("failed to serialize ddl checkpoint ts", K(ret), K(len), K(new_pos), K_(ddl_checkpoint_scn));
} else if (new_pos - pos < length_ && OB_FAIL(snapshot_version_.fixed_serialize(buf, len, new_pos))) {
} else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, snapshot_version_))) {
LOG_WARN("failed to serialize snapshot version", K(ret), K(len), K(new_pos), K_(snapshot_version));
} else if (new_pos - pos < length_ && OB_FAIL(multi_version_start_.fixed_serialize(buf, len, new_pos))) {
} else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, multi_version_start_))) {
LOG_WARN("failed to serialize multi version start", K(ret), K(len), K(new_pos), K_(multi_version_start));
} else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i8(buf, len, new_pos, static_cast<int8_t>(compat_mode_)))) {
LOG_WARN("failed to serialize auto inc seq", K(ret), K(len), K(new_pos));
@ -467,7 +467,7 @@ int ObTabletMeta::serialize(char *buf, const int64_t len, int64_t &pos)
LOG_WARN("failed to serialize table store flag", K(ret), K(len), K(new_pos));
} else if (new_pos - pos < length_ && OB_FAIL(ddl_start_scn_.fixed_serialize(buf, len, new_pos))) {
LOG_WARN("failed to serialize ddl start log ts", K(ret), K(len), K(new_pos), K_(ddl_start_scn));
} else if (new_pos - pos < length_ && OB_FAIL(ddl_snapshot_version_.fixed_serialize(buf, len, new_pos))) {
} else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, ddl_snapshot_version_))) {
LOG_WARN("failed to serialize ddl snapshot version", K(ret), K(len), K(new_pos), K_(ddl_snapshot_version));
} else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, max_sync_storage_schema_version_))) {
LOG_WARN("failed to serialize max_sync_storage_schema_version", K(ret), K(len), K(new_pos), K_(max_sync_storage_schema_version));
@ -526,9 +526,9 @@ int ObTabletMeta::deserialize(
LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len), K(new_pos));
} else if (new_pos - pos < length_ && OB_FAIL(ddl_checkpoint_scn_.fixed_deserialize(buf, len, new_pos))) {
LOG_WARN("failed to deserialize ddl checkpoint ts", K(ret), K(len), K(new_pos));
} else if (new_pos - pos < length_ && OB_FAIL(snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
} else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &snapshot_version_))) {
LOG_WARN("failed to deserialize snapshot version", K(ret), K(len));
} else if (new_pos - pos < length_ && OB_FAIL(multi_version_start_.fixed_deserialize(buf, len, new_pos))) {
} else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &multi_version_start_))) {
LOG_WARN("failed to deserialize multi version start", K(ret), K(len));
} else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i8(buf, len, new_pos, (int8_t*)(&compat_mode)))) {
LOG_WARN("failed to deserialize compat mode", K(ret), K(len), K(new_pos));
@ -546,7 +546,7 @@ int ObTabletMeta::deserialize(
LOG_WARN("failed to deserialize table store flag", K(ret), K(len), K(new_pos));
} else if (new_pos - pos < length_ && OB_FAIL(ddl_start_scn_.fixed_deserialize(buf, len, new_pos))) {
LOG_WARN("failed to deserialize ddl start log ts", K(ret), K(len), K(new_pos));
} else if (new_pos - pos < length_ && OB_FAIL(ddl_snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
} else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &ddl_snapshot_version_))) {
LOG_WARN("failed to deserialize ddl snapshot version", K(ret), K(len), K(new_pos));
} else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &max_sync_storage_schema_version_))) {
LOG_WARN("failed to deserialize max_sync_storage_schema_version_", K(ret), K(len), K(new_pos));
@ -580,8 +580,8 @@ int64_t ObTabletMeta::get_serialize_size() const
size += start_scn_.get_fixed_serialize_size();
size += clog_checkpoint_scn_.get_fixed_serialize_size();
size += ddl_checkpoint_scn_.get_fixed_serialize_size();
size += snapshot_version_.get_fixed_serialize_size();
size += multi_version_start_.get_fixed_serialize_size();
size += serialization::encoded_length_i64(snapshot_version_);
size += serialization::encoded_length_i64(multi_version_start_);
size += serialization::encoded_length_i8(static_cast<int8_t>(compat_mode_));
size += autoinc_seq_.get_serialize_size();
size += ha_status_.get_serialize_size();
@ -590,7 +590,7 @@ int64_t ObTabletMeta::get_serialize_size() const
size += ddl_data_.get_serialize_size();
size += table_store_flag_.get_serialize_size();
size += ddl_start_scn_.get_fixed_serialize_size();
size += ddl_snapshot_version_.get_fixed_serialize_size();
size += serialization::encoded_length_i64(ddl_snapshot_version_);
size += serialization::encoded_length_i64(max_sync_storage_schema_version_);
return size;
}
@ -734,8 +734,8 @@ ObMigrationTabletParam::ObMigrationTabletParam()
start_scn_(),
clog_checkpoint_scn_(),
ddl_checkpoint_scn_(),
snapshot_version_(),
multi_version_start_(),
snapshot_version_(OB_INVALID_TIMESTAMP),
multi_version_start_(OB_INVALID_TIMESTAMP),
compat_mode_(lib::Worker::CompatMode::INVALID),
autoinc_seq_(),
ha_status_(),
@ -746,7 +746,7 @@ ObMigrationTabletParam::ObMigrationTabletParam()
medium_info_list_(compaction::ObMediumCompactionInfoList::MEDIUM_LIST_IN_STORAGE),
table_store_flag_(),
ddl_start_scn_(),
ddl_snapshot_version_(),
ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
max_sync_storage_schema_version_(0)
{
}
@ -757,7 +757,7 @@ bool ObMigrationTabletParam::is_valid() const
&& tablet_id_.is_valid()
&& data_tablet_id_.is_valid()
//&& create_scn_ > OB_INVALID_TIMESTAMP
&& multi_version_start_ >= SCN::min_scn()
&& multi_version_start_ >= 0
&& multi_version_start_ <= snapshot_version_
&& compat_mode_ != lib::Worker::CompatMode::INVALID
&& medium_info_list_.is_valid()
@ -799,9 +799,9 @@ int ObMigrationTabletParam::serialize(char *buf, const int64_t len, int64_t &pos
LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(clog_checkpoint_scn));
} else if (OB_FAIL(ddl_checkpoint_scn_.fixed_serialize(buf, len, new_pos))) {
LOG_WARN("failed to serialize ddl checkpoint ts", K(ret), K(len), K(new_pos), K_(ddl_checkpoint_scn));
} else if (OB_FAIL(snapshot_version_.fixed_serialize(buf, len, new_pos))) {
} else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, snapshot_version_))) {
LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(snapshot_version));
} else if (OB_FAIL(multi_version_start_.fixed_serialize(buf, len, new_pos))) {
} else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, multi_version_start_))) {
LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(multi_version_start));
} else if (OB_FAIL(serialization::encode_i8(buf, len, new_pos, static_cast<int8_t>(compat_mode_)))) {
LOG_WARN("failed to serialize compat mode", K(ret), K(len), K(new_pos));
@ -823,7 +823,7 @@ int ObMigrationTabletParam::serialize(char *buf, const int64_t len, int64_t &pos
LOG_WARN("failed to serialize table store flag", K(ret), K(len), K(new_pos));
} else if (OB_FAIL(ddl_start_scn_.fixed_serialize(buf, len, new_pos))) {
LOG_WARN("failed to serialize ddl start log ts", K(ret), K(len), K(new_pos), K_(ddl_start_scn));
} else if (OB_FAIL(ddl_snapshot_version_.fixed_serialize(buf, len, new_pos))) {
} else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, ddl_snapshot_version_))) {
LOG_WARN("failed to serialize ddl snapshot version", K(ret), K(len), K(new_pos), K_(ddl_snapshot_version));
} else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, max_sync_storage_schema_version_))) {
LOG_WARN("failed to serialize max_sync_storage_schema_version", K(ret), K(len), K(new_pos), K_(max_sync_storage_schema_version));
@ -862,9 +862,9 @@ int ObMigrationTabletParam::deserialize(const char *buf, const int64_t len, int6
LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len), K(new_pos));
} else if (OB_FAIL(ddl_checkpoint_scn_.fixed_deserialize(buf, len, new_pos))) {
LOG_WARN("failed to deserialize ddl checkpoint ts", K(ret), K(len), K(new_pos));
} else if (OB_FAIL(snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
} else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &snapshot_version_))) {
LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len));
} else if (OB_FAIL(multi_version_start_.fixed_deserialize(buf, len, new_pos))) {
} else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &multi_version_start_))) {
LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len));
} else if (OB_FAIL(serialization::decode_i8(buf, len, new_pos, (int8_t*)(&compat_mode)))) {
LOG_WARN("failed to deserialize compat mode", K(ret), K(len), K(new_pos));
@ -886,7 +886,7 @@ int ObMigrationTabletParam::deserialize(const char *buf, const int64_t len, int6
LOG_WARN("failed to deserialize table store flag", K(ret), K(len), K(new_pos));
} else if (OB_FAIL(ddl_start_scn_.fixed_deserialize(buf, len, new_pos))) {
LOG_WARN("failed to deserialize ddl start log ts", K(ret), K(len), K(new_pos));
} else if (OB_FAIL(ddl_snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
} else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &ddl_snapshot_version_))) {
LOG_WARN("failed to deserialize ddl snapshot version", K(ret), K(len), K(new_pos));
} else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &max_sync_storage_schema_version_))) {
LOG_WARN("failed to deserialize max sync storage schema version", K(ret), K(len), K(new_pos));
@ -909,8 +909,8 @@ int64_t ObMigrationTabletParam::get_serialize_size() const
size += start_scn_.get_fixed_serialize_size();
size += clog_checkpoint_scn_.get_fixed_serialize_size();
size += ddl_checkpoint_scn_.get_fixed_serialize_size();
size += snapshot_version_.get_fixed_serialize_size();
size += multi_version_start_.get_fixed_serialize_size();
size += serialization::encoded_length_i64(snapshot_version_);
size += serialization::encoded_length_i64(multi_version_start_);
size += serialization::encoded_length_i8(static_cast<int8_t>(compat_mode_));
size += autoinc_seq_.get_serialize_size();
size += ha_status_.get_serialize_size();
@ -921,7 +921,7 @@ int64_t ObMigrationTabletParam::get_serialize_size() const
size += medium_info_list_.get_serialize_size();
size += table_store_flag_.get_serialize_size();
size += ddl_start_scn_.get_fixed_serialize_size();
size += ddl_snapshot_version_.get_fixed_serialize_size();
size += serialization::encoded_length_i64(ddl_snapshot_version_);
size += serialization::encoded_length_i64(max_sync_storage_schema_version_);
return size;
}
@ -935,8 +935,8 @@ void ObMigrationTabletParam::reset()
start_scn_.reset();
clog_checkpoint_scn_.reset();
ddl_checkpoint_scn_.reset();
snapshot_version_.reset();
multi_version_start_.reset();
snapshot_version_ = OB_INVALID_TIMESTAMP;
multi_version_start_ = OB_INVALID_TIMESTAMP;
compat_mode_ = lib::Worker::CompatMode::INVALID;
autoinc_seq_.reset();
ha_status_.reset();
@ -947,7 +947,7 @@ void ObMigrationTabletParam::reset()
medium_info_list_.reset();
table_store_flag_.reset();
ddl_start_scn_.reset();
ddl_snapshot_version_.reset();
ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
max_sync_storage_schema_version_ = 0;
}

20
src/storage/tablet/ob_tablet_meta.h
View File

@ -71,7 +71,7 @@ public:
const common::ObTabletID &lob_meta_tablet_id,
const common::ObTabletID &lob_piece_tablet_id,
const palf::SCN create_scn,
const palf::SCN snapshot_version,
const int64_t snapshot_version,
const lib::Worker::CompatMode compat_mode,
const ObTabletTableStoreFlag &table_store_flag,
const int64_t max_sync_storage_schema_version);
@ -91,8 +91,8 @@ public:
int init(
common::ObIAllocator &allocator,
const ObTabletMeta &old_tablet_meta,
const palf::SCN &snapshot_version,
const palf::SCN multi_version_start,
const int64_t snapshot_version,
const int64_t multi_version_start,
const ObTabletTxMultiSourceDataUnit &tx_data,
const ObTabletBindingInfo &ddl_data,
const share::ObTabletAutoincSeq &autoinc_seq,
@ -100,7 +100,7 @@ public:
const palf::SCN clog_checkpoint_scn = palf::SCN::min_scn(),
const palf::SCN ddl_checkpoint_scn = palf::SCN::min_scn(),
const palf::SCN ddl_start_scn = palf::SCN::min_scn(),
const palf::SCN ddl_snapshot_version = palf::SCN::min_scn());
const int64_t ddl_snapshot_version = 0);
int init(
common::ObIAllocator &allocator,
const ObMigrationTabletParam &param);
@ -166,8 +166,8 @@ public:
palf::SCN clog_checkpoint_scn_;
palf::SCN ddl_checkpoint_scn_;
// snapshot_version of last minor
palf::SCN snapshot_version_;
palf::SCN multi_version_start_;
int64_t snapshot_version_;
int64_t multi_version_start_;
lib::Worker::CompatMode compat_mode_;
share::ObTabletAutoincSeq autoinc_seq_;
ObTabletHAStatus ha_status_;
@ -176,7 +176,7 @@ public:
ObTabletBindingInfo ddl_data_;
ObTabletTableStoreFlag table_store_flag_;
palf::SCN ddl_start_scn_;
palf::SCN ddl_snapshot_version_;
int64_t ddl_snapshot_version_;
int64_t max_sync_storage_schema_version_;
private:
@ -237,8 +237,8 @@ public:
palf::SCN start_scn_; // for migration
palf::SCN clog_checkpoint_scn_;
palf::SCN ddl_checkpoint_scn_;
palf::SCN snapshot_version_;
palf::SCN multi_version_start_;
int64_t snapshot_version_;
int64_t multi_version_start_;
lib::Worker::CompatMode compat_mode_;
share::ObTabletAutoincSeq autoinc_seq_;
ObTabletHAStatus ha_status_;
@ -249,7 +249,7 @@ public:
compaction::ObMediumCompactionInfoList medium_info_list_;
ObTabletTableStoreFlag table_store_flag_;
palf::SCN ddl_start_scn_;
palf::SCN ddl_snapshot_version_;
int64_t ddl_snapshot_version_;
// max_sync_version may less than storage_schema.schema_version_ when major update schema
int64_t max_sync_storage_schema_version_;
};

2
src/storage/tablet/ob_tablet_service_clog_replay_executor.cpp
View File

@ -103,7 +103,7 @@ int ObTabletServiceClogReplayExecutor::replay_update_storage_schema(
} else {
LOG_WARN("failed to get tablet", K(ret), K(tablet_id));
}
} else if (OB_FAIL(handle.get_obj()->replay_update_storage_schema(scn.get_val_for_lsn_allocator(), buf, buf_size, tmp_pos))) {
} else if (OB_FAIL(handle.get_obj()->replay_update_storage_schema(scn, buf, buf_size, tmp_pos))) {
LOG_WARN("update tablet storage schema fail", K(ret), K(tablet_id), K(scn));
}
return ret;

4
unittest/storage/test_compaction_policy.cpp
View File

@ -362,7 +362,7 @@ int TestCompactionPolicy::mock_tablet(
K(table_schema), K(compat_mode));
} else {
tablet->tablet_meta_.clog_checkpoint_scn_.convert_tmp(clog_checkpoint_ts);
tablet->tablet_meta_.snapshot_version_.convert_tmp(snapshot_version);
tablet->tablet_meta_.snapshot_version_ = snapshot_version;
}
return ret;
}
@ -726,7 +726,7 @@ TEST_F(TestCompactionPolicy, check_mini_merge_basic)
ASSERT_EQ(3, result.handle_.get_count());
tablet_handle_.get_obj()->tablet_meta_.clog_checkpoint_scn_.convert_tmp(300);
tablet_handle_.get_obj()->tablet_meta_.snapshot_version_.convert_tmp(300);
tablet_handle_.get_obj()->tablet_meta_.snapshot_version_ = 300;
result.reset();
ret = ObPartitionMergePolicy::get_mini_merge_tables(param, 0, *tablet_handle_.get_obj(), result);
ASSERT_EQ(OB_NO_NEED_MERGE, ret);