[FEAT MERGE] column store ddl
Co-authored-by: AnimationFan <30674773338@qq.com> Co-authored-by: simonjoylet <simonjoylet@gmail.com> Co-authored-by: Monk-Liu <1152761042@qq.com>
This commit is contained in:
Charles0429
612
src/storage/ddl/ob_direct_load_struct.h
Normal file
612
src/storage/ddl/ob_direct_load_struct.h
Normal file
@ -0,0 +1,612 @@
|
||||
/**
|
||||
* Copyright (c) 2021 OceanBase
|
||||
* OceanBase CE is licensed under Mulan PubL v2.
|
||||
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
||||
* You may obtain a copy of Mulan PubL v2 at:
|
||||
* http://license.coscl.org.cn/MulanPubL-2.0
|
||||
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
||||
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
||||
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
||||
* See the Mulan PubL v2 for more details.
|
||||
*/
|
||||
|
||||
#ifndef OCEANBASE_STORAGE_DDL_OB_DIRECT_LOAD_COMMON_H
|
||||
#define OCEANBASE_STORAGE_DDL_OB_DIRECT_LOAD_COMMON_H
|
||||
|
||||
#include "lib/lock/ob_mutex.h"
|
||||
#include "lib/lock/ob_bucket_lock.h"
|
||||
#include "common/ob_tablet_id.h"
|
||||
#include "common/row/ob_row_iterator.h"
|
||||
#include "share/scn.h"
|
||||
#include "share/ob_tablet_autoincrement_param.h"
|
||||
#include "share/scheduler/ob_tenant_dag_scheduler.h"
|
||||
#include "share/ob_ddl_common.h"
|
||||
#include "sql/engine/basic/ob_chunk_datum_store.h"
|
||||
#include "sql/engine/basic/chunk_store/ob_compact_store.h"
|
||||
#include "storage/ob_i_table.h"
|
||||
#include "storage/access/ob_store_row_iterator.h"
|
||||
#include "storage/blocksstable/index_block/ob_index_block_builder.h"
|
||||
#include "storage/blocksstable/ob_macro_block_struct.h"
|
||||
#include "storage/blocksstable/ob_imacro_block_flush_callback.h"
|
||||
#include "storage/ddl/ob_ddl_redo_log_writer.h"
|
||||
#include "storage/lob/ob_lob_meta.h"
|
||||
|
||||
namespace oceanbase
|
||||
{
|
||||
namespace sql
|
||||
{
|
||||
class ObPxMultiPartSSTableInsertOp;
|
||||
class ObExecContext;
|
||||
}
|
||||
|
||||
namespace storage
|
||||
{
|
||||
class ObTablet;
|
||||
|
||||
struct ObBatchSliceWriteInfo final
|
||||
{
|
||||
public:
|
||||
ObBatchSliceWriteInfo()
|
||||
: data_tablet_id_(), // tablet id of the data table.
|
||||
ls_id_(),
|
||||
trans_version_(0),
|
||||
direct_load_type_(),
|
||||
trans_id_(),
|
||||
seq_no_(0)
|
||||
{ }
|
||||
ObBatchSliceWriteInfo(const common::ObTabletID &tablet_id, const share::ObLSID &ls_id, const int64_t &trans_version,
|
||||
const ObDirectLoadType &direct_load_type, const transaction::ObTransID &trans_id, const int64_t &seq_no)
|
||||
: data_tablet_id_(tablet_id),
|
||||
ls_id_(ls_id),
|
||||
trans_version_(trans_version),
|
||||
direct_load_type_(direct_load_type),
|
||||
trans_id_(trans_id),
|
||||
seq_no_(seq_no)
|
||||
|
||||
{ }
|
||||
~ObBatchSliceWriteInfo() = default;
|
||||
TO_STRING_KV(K(ls_id_), K(data_tablet_id_), K(trans_version_), K(direct_load_type_));
|
||||
public:
|
||||
common::ObTabletID data_tablet_id_;
|
||||
share::ObLSID ls_id_;
|
||||
int64_t trans_version_;
|
||||
ObDirectLoadType direct_load_type_;
|
||||
transaction::ObTransID trans_id_;
|
||||
int64_t seq_no_; //
|
||||
};
|
||||
|
||||
struct ObTabletDirectLoadMgrKey final
|
||||
{
|
||||
public:
|
||||
ObTabletDirectLoadMgrKey()
|
||||
: tablet_id_(), is_full_direct_load_(false)
|
||||
{ }
|
||||
ObTabletDirectLoadMgrKey(const common::ObTabletID &tablet_id, const bool is_full_direct_load)
|
||||
: tablet_id_(tablet_id), is_full_direct_load_(is_full_direct_load)
|
||||
{ }
|
||||
~ObTabletDirectLoadMgrKey() = default;
|
||||
uint64_t hash() const {
|
||||
return tablet_id_.hash() + murmurhash(&is_full_direct_load_, sizeof(is_full_direct_load_), 0);
|
||||
}
|
||||
int hash(uint64_t &hash_val) const {hash_val = hash(); return OB_SUCCESS;}
|
||||
bool is_valid() const { return tablet_id_.is_valid(); }
|
||||
bool operator == (const ObTabletDirectLoadMgrKey &other) const {
|
||||
return tablet_id_ == other.tablet_id_ && is_full_direct_load_ == other.is_full_direct_load_; }
|
||||
TO_STRING_KV(K_(tablet_id), K_(is_full_direct_load));
|
||||
public:
|
||||
common::ObTabletID tablet_id_;
|
||||
bool is_full_direct_load_;
|
||||
};
|
||||
|
||||
struct ObDirectLoadSliceInfo final
|
||||
{
|
||||
public:
|
||||
ObDirectLoadSliceInfo()
|
||||
: is_full_direct_load_(false), is_lob_slice_(false), ls_id_(), data_tablet_id_(), slice_id_(-1),
|
||||
context_id_(0)
|
||||
{ }
|
||||
~ObDirectLoadSliceInfo() = default;
|
||||
bool is_valid() const { return ls_id_.is_valid() && data_tablet_id_.is_valid() && slice_id_ >= 0 && context_id_ >= 0; }
|
||||
TO_STRING_KV(K_(is_full_direct_load), K_(is_lob_slice), K_(ls_id), K_(data_tablet_id), K_(slice_id), K_(context_id));
|
||||
public:
|
||||
bool is_full_direct_load_;
|
||||
bool is_lob_slice_;
|
||||
share::ObLSID ls_id_;
|
||||
common::ObTabletID data_tablet_id_;
|
||||
int64_t slice_id_;
|
||||
int64_t context_id_;
|
||||
DISALLOW_COPY_AND_ASSIGN(ObDirectLoadSliceInfo);
|
||||
};
|
||||
|
||||
struct ObTableSchemaItem final
|
||||
{
|
||||
public:
|
||||
ObTableSchemaItem()
|
||||
: is_column_store_(false), is_index_table_(false), is_unique_index_(false), rowkey_column_num_(0),
|
||||
compress_type_(NONE_COMPRESSOR), lob_inrow_threshold_(OB_DEFAULT_LOB_INROW_THRESHOLD)
|
||||
{}
|
||||
~ObTableSchemaItem() { reset(); }
|
||||
void reset()
|
||||
{
|
||||
is_column_store_ = false;
|
||||
is_index_table_ = false;
|
||||
is_unique_index_ = false;
|
||||
rowkey_column_num_ = 0;
|
||||
compress_type_ = NONE_COMPRESSOR;
|
||||
lob_inrow_threshold_ = OB_DEFAULT_LOB_INROW_THRESHOLD;
|
||||
}
|
||||
TO_STRING_KV(K(is_column_store_), K(is_index_table_), K(is_unique_index_), K(rowkey_column_num_),
|
||||
K(compress_type_), K_(lob_inrow_threshold));
|
||||
|
||||
public:
|
||||
bool is_column_store_;
|
||||
bool is_index_table_;
|
||||
bool is_unique_index_;
|
||||
int64_t rowkey_column_num_;
|
||||
common::ObCompressorType compress_type_;
|
||||
int64_t lob_inrow_threshold_;
|
||||
};
|
||||
|
||||
struct ObColumnSchemaItem final
|
||||
{
|
||||
public:
|
||||
ObColumnSchemaItem()
|
||||
: is_valid_(false), col_type_(), col_accuracy_()
|
||||
{}
|
||||
ObColumnSchemaItem(const ObColumnSchemaItem &other)
|
||||
{
|
||||
*this = other;
|
||||
}
|
||||
~ObColumnSchemaItem() { reset(); }
|
||||
void reset()
|
||||
{
|
||||
is_valid_ = false;
|
||||
col_type_.reset();
|
||||
col_accuracy_.reset();
|
||||
}
|
||||
ObColumnSchemaItem &operator=(const ObColumnSchemaItem &other)
|
||||
{
|
||||
is_valid_ = other.is_valid_;
|
||||
col_type_ = other.col_type_;
|
||||
col_accuracy_ = other.col_accuracy_;
|
||||
return *this;
|
||||
}
|
||||
int assign(const ObColumnSchemaItem &other)
|
||||
{
|
||||
is_valid_ = other.is_valid_;
|
||||
col_type_ = other.col_type_;
|
||||
col_accuracy_ = other.col_accuracy_;
|
||||
return OB_SUCCESS;
|
||||
}
|
||||
TO_STRING_KV(K(is_valid_), K(col_type_), K(col_accuracy_));
|
||||
public:
|
||||
bool is_valid_;
|
||||
common::ObObjMeta col_type_;
|
||||
ObAccuracy col_accuracy_;
|
||||
};
|
||||
|
||||
// usued in replay replay and runtime execution
|
||||
struct ObDirectInsertCommonParam final
|
||||
{
|
||||
public:
|
||||
ObDirectInsertCommonParam()
|
||||
: ls_id_(), tablet_id_(), direct_load_type_(DIRECT_LOAD_INVALID), data_format_version_(0), read_snapshot_(0)
|
||||
{}
|
||||
~ObDirectInsertCommonParam() = default;
|
||||
bool is_valid() const { return ls_id_.is_valid() && tablet_id_.is_valid()
|
||||
&& data_format_version_ >= 0 && read_snapshot_ >= 0 && DIRECT_LOAD_INVALID <= direct_load_type_ && direct_load_type_ <= DIRECT_LOAD_MAX;
|
||||
}
|
||||
TO_STRING_KV(K_(ls_id), K_(tablet_id), K_(direct_load_type), K_(data_format_version), K_(read_snapshot));
|
||||
public:
|
||||
share::ObLSID ls_id_;
|
||||
common::ObTabletID tablet_id_;
|
||||
ObDirectLoadType direct_load_type_;
|
||||
uint64_t data_format_version_;
|
||||
// read_snapshot_ is used to scan the source data.
|
||||
// For full direct load task, it is also the commit version of the target macro block.
|
||||
int64_t read_snapshot_;
|
||||
};
|
||||
|
||||
// only used in runtime execution
|
||||
struct ObDirectInsertRuntimeOnlyParam final
|
||||
{
|
||||
public:
|
||||
ObDirectInsertRuntimeOnlyParam()
|
||||
: exec_ctx_(nullptr), task_id_(0), table_id_(OB_INVALID_ID), schema_version_(0), task_cnt_(0), need_online_opt_stat_gather_(false), trans_id_(), seq_no_(0)
|
||||
{}
|
||||
~ObDirectInsertRuntimeOnlyParam() = default;
|
||||
bool is_valid() const { return OB_INVALID_ID != task_id_ && OB_INVALID_ID != table_id_ && schema_version_ > 0 && task_cnt_ >= 0; }
|
||||
TO_STRING_KV(KP_(exec_ctx), K_(task_id), K_(table_id), K_(schema_version), K_(task_cnt), K_(need_online_opt_stat_gather), K_(trans_id), K_(seq_no));
|
||||
public:
|
||||
sql::ObExecContext *exec_ctx_;
|
||||
int64_t task_id_;
|
||||
int64_t table_id_;
|
||||
int64_t schema_version_;
|
||||
int64_t task_cnt_;
|
||||
bool need_online_opt_stat_gather_;
|
||||
// default value is invalid tx_id,
|
||||
// participant tx_id for the incremental direct load,
|
||||
// and invalid tx_id for the full_direct_load.
|
||||
transaction::ObTransID trans_id_;
|
||||
// default value is 0,
|
||||
// sequence number for the incremental direct load,
|
||||
// fixed 0 for the full direct load.
|
||||
int64_t seq_no_; //
|
||||
};
|
||||
|
||||
// full parameters used by runtime execution
|
||||
struct ObTabletDirectLoadInsertParam final
|
||||
{
|
||||
public:
|
||||
ObTabletDirectLoadInsertParam()
|
||||
: common_param_(), runtime_only_param_(), is_replay_(false)
|
||||
{}
|
||||
~ObTabletDirectLoadInsertParam() = default;
|
||||
bool is_valid() const {
|
||||
return (!is_replay_ && (common_param_.is_valid() && runtime_only_param_.is_valid()))
|
||||
|| (is_replay_ && common_param_.is_valid());
|
||||
}
|
||||
int assign(const ObTabletDirectLoadInsertParam &other_param);
|
||||
TO_STRING_KV(K_(common_param), K_(runtime_only_param), K_(is_replay));
|
||||
public:
|
||||
ObDirectInsertCommonParam common_param_;
|
||||
ObDirectInsertRuntimeOnlyParam runtime_only_param_;
|
||||
bool is_replay_;
|
||||
};
|
||||
|
||||
// for ddl insert row.
|
||||
class ObDDLInsertRowIterator : public ObIStoreRowIterator
|
||||
{
|
||||
public:
|
||||
ObDDLInsertRowIterator(
|
||||
sql::ObPxMultiPartSSTableInsertOp *op,
|
||||
const bool is_slice_empty,
|
||||
const share::ObLSID &ls_id,
|
||||
const common::ObTabletID &tablet_id,
|
||||
const int64_t rowkey_cnt,
|
||||
const int64_t snapshot_version,
|
||||
const int64_t context_id);
|
||||
virtual ~ObDDLInsertRowIterator();
|
||||
virtual int get_next_row(const blocksstable::ObDatumRow *&row) override;
|
||||
TO_STRING_KV(K_(ls_id), K_(current_tablet_id), K_(current_row), K_(is_slice_empty), K_(is_next_row_cached), K_(rowkey_count), K_(snapshot_version),
|
||||
K_(lob_slice_id), K_(lob_id_cache), K_(context_id));
|
||||
public:
|
||||
int switch_to_new_lob_slice();
|
||||
int close_lob_sstable_slice();
|
||||
inline int64_t get_lob_slice_id() { return lob_slice_id_; }
|
||||
inline share::ObTabletCacheInterval &get_lob_id_cache() { return lob_id_cache_; }
|
||||
private:
|
||||
static const int64_t AUTO_INC_CACHE_SIZE = 100000; // 10w.
|
||||
ObArenaAllocator lob_allocator_;
|
||||
sql::ObPxMultiPartSSTableInsertOp *op_;
|
||||
share::ObLSID ls_id_;
|
||||
common::ObTabletID current_tablet_id_; // data_tablet_id rather than lob_meta_tablet_id.
|
||||
blocksstable::ObDatumRow current_row_;
|
||||
bool is_next_row_cached_;
|
||||
bool is_slice_empty_; // without data.
|
||||
int64_t rowkey_count_;
|
||||
int64_t snapshot_version_;
|
||||
int64_t lob_slice_id_;
|
||||
share::ObTabletCacheInterval lob_id_cache_;
|
||||
int64_t context_id_;
|
||||
};
|
||||
|
||||
class ObLobMetaRowIterator : public ObIStoreRowIterator
|
||||
{
|
||||
public:
|
||||
ObLobMetaRowIterator();
|
||||
virtual ~ObLobMetaRowIterator();
|
||||
int init(ObLobMetaWriteIter *iter,
|
||||
const transaction::ObTransID &trans_id,
|
||||
const int64_t trans_version,
|
||||
const int64_t sql_no);
|
||||
void reset();
|
||||
void reuse();
|
||||
virtual int get_next_row(const blocksstable::ObDatumRow *&row) override;
|
||||
// private:
|
||||
public:
|
||||
bool is_inited_;
|
||||
ObLobMetaWriteIter *iter_;
|
||||
transaction::ObTransID trans_id_;
|
||||
int64_t trans_version_;
|
||||
int64_t sql_no_;
|
||||
blocksstable::ObDatumRow tmp_row_;
|
||||
ObLobMetaWriteResult lob_meta_write_result_;
|
||||
};
|
||||
|
||||
struct ObTabletDDLParam final
|
||||
{
|
||||
public:
|
||||
ObTabletDDLParam();
|
||||
~ObTabletDDLParam();
|
||||
bool is_valid() const;
|
||||
TO_STRING_KV(K_(direct_load_type), K_(ls_id), K_(start_scn), K_(commit_scn), K_(data_format_version), K_(table_key), K_(snapshot_version));
|
||||
public:
|
||||
ObDirectLoadType direct_load_type_;
|
||||
share::ObLSID ls_id_;
|
||||
share::SCN start_scn_;
|
||||
share::SCN commit_scn_;
|
||||
uint64_t data_format_version_;
|
||||
ObITable::TableKey table_key_;
|
||||
int64_t snapshot_version_; // used for full direct load only.
|
||||
};
|
||||
|
||||
struct ObDDLTableMergeDagParam : public share::ObIDagInitParam
|
||||
{
|
||||
public:
|
||||
ObDDLTableMergeDagParam()
|
||||
: direct_load_type_(ObDirectLoadType::DIRECT_LOAD_INVALID),
|
||||
ls_id_(),
|
||||
tablet_id_(),
|
||||
rec_scn_(share::SCN::min_scn()),
|
||||
is_commit_(false),
|
||||
start_scn_(share::SCN::min_scn()),
|
||||
data_format_version_(0),
|
||||
snapshot_version_(0)
|
||||
{ }
|
||||
bool is_valid() const
|
||||
{
|
||||
bool is_valid = data_format_version_ > 0 && snapshot_version_ > 0;
|
||||
if (is_full_direct_load(direct_load_type_)) {
|
||||
is_valid = ls_id_.is_valid() && tablet_id_.is_valid() && start_scn_.is_valid_and_not_min();
|
||||
} else if (is_incremental_direct_load(direct_load_type_)) {
|
||||
is_valid = ls_id_.is_valid() && tablet_id_.is_valid();
|
||||
}
|
||||
return is_valid;
|
||||
}
|
||||
virtual ~ObDDLTableMergeDagParam() = default;
|
||||
TO_STRING_KV(K_(direct_load_type), K_(ls_id), K_(tablet_id), K_(rec_scn), K_(is_commit), K_(start_scn),
|
||||
K_(data_format_version), K_(snapshot_version));
|
||||
public:
|
||||
ObDirectLoadType direct_load_type_;
|
||||
share::ObLSID ls_id_;
|
||||
ObTabletID tablet_id_;
|
||||
share::SCN rec_scn_;
|
||||
bool is_commit_;
|
||||
share::SCN start_scn_; // start log ts at schedule, for skipping expired task
|
||||
uint64_t data_format_version_;
|
||||
int64_t snapshot_version_;
|
||||
};
|
||||
|
||||
// column organization of row in ObChunkDatumStore::SotredRow
|
||||
// <rowkey_columns, multi_version_columns, other_columns_if_exist>
|
||||
// this organization is same as row of all_cg in macro block
|
||||
// and match the column index in ObStorageColumnGroupSchema
|
||||
class ObTabletSliceStore
|
||||
{
|
||||
public:
|
||||
ObTabletSliceStore() {}
|
||||
virtual ~ObTabletSliceStore() {}
|
||||
virtual int append_row(const blocksstable::ObDatumRow &datum_row) = 0;
|
||||
virtual int close() = 0;
|
||||
virtual int64_t get_row_count() const { return 0; } // dummy one
|
||||
DECLARE_PURE_VIRTUAL_TO_STRING;
|
||||
};
|
||||
|
||||
class ObChunkSliceStore : public ObTabletSliceStore
|
||||
{
|
||||
public:
|
||||
ObChunkSliceStore() : is_inited_(false), arena_allocator_(nullptr), rowkey_column_count_(0) {}
|
||||
virtual ~ObChunkSliceStore() {}
|
||||
int init(const int64_t rowkey_column_count, ObArenaAllocator &allocator,
|
||||
const ObIArray<ObColumnSchemaItem> &col_schema,
|
||||
common::ObCompressorType compress_type = NONE_COMPRESSOR);
|
||||
virtual int append_row(const blocksstable::ObDatumRow &datum_row) override;
|
||||
virtual int close() override;
|
||||
virtual int64_t get_row_count() const { return datum_store_.get_row_cnt(); }
|
||||
TO_STRING_KV(K(is_inited_), KP(arena_allocator_), K(datum_store_), K(endkey_), K(rowkey_column_count_));
|
||||
public:
|
||||
bool is_inited_;
|
||||
ObArenaAllocator *arena_allocator_;
|
||||
sql::ObCompactStore datum_store_;
|
||||
blocksstable::ObDatumRowkey endkey_;
|
||||
int64_t rowkey_column_count_;
|
||||
};
|
||||
|
||||
class ObMacroBlockSliceStore: public ObTabletSliceStore
|
||||
{
|
||||
public:
|
||||
ObMacroBlockSliceStore() : is_inited_(false) {}
|
||||
virtual ~ObMacroBlockSliceStore() {}
|
||||
int init(
|
||||
ObTabletDirectLoadMgr *tablet_direct_load_mgr,
|
||||
const blocksstable::ObMacroDataSeq &data_seq,
|
||||
const share::SCN &start_scn);
|
||||
virtual int append_row(const blocksstable::ObDatumRow &datum_row) override;
|
||||
virtual int close() override;
|
||||
TO_STRING_KV(K(is_inited_), K(macro_block_writer_));
|
||||
private:
|
||||
bool is_inited_;
|
||||
ObDDLRedoLogWriter ddl_redo_writer_;
|
||||
ObDDLRedoLogWriterCallback write_ddl_redo_callback_;
|
||||
blocksstable::ObMacroBlockWriter macro_block_writer_;
|
||||
};
|
||||
|
||||
class ObTabletDirectLoadMgr;
|
||||
|
||||
struct ObInsertMonitor final{
|
||||
public:
|
||||
ObInsertMonitor(int64_t &tmp_insert_row, int64_t &cg_insert_row):inserted_row_cnt_(tmp_insert_row), inserted_cg_row_cnt_(cg_insert_row)
|
||||
{};
|
||||
~ObInsertMonitor();
|
||||
void set(sql::ObMonitorNode &op_monitor_info);
|
||||
|
||||
public:
|
||||
int64_t &inserted_row_cnt_;
|
||||
int64_t &inserted_cg_row_cnt_;
|
||||
};
|
||||
|
||||
class ObDirectLoadSliceWriter final
|
||||
{
|
||||
public:
|
||||
ObDirectLoadSliceWriter();
|
||||
~ObDirectLoadSliceWriter();
|
||||
int init(
|
||||
ObTabletDirectLoadMgr *tablet_direct_load_mgr,
|
||||
const blocksstable::ObMacroDataSeq &start_seq);
|
||||
int fill_sstable_slice(
|
||||
const share::SCN &start_scn,
|
||||
const uint64_t table_id,
|
||||
const ObTabletID &curr_tablet_id,
|
||||
ObIStoreRowIterator *row_iter,
|
||||
const ObTableSchemaItem &schema_item,
|
||||
const ObDirectLoadType &direct_load_type,
|
||||
const ObArray<ObColumnSchemaItem> &column_items,
|
||||
int64_t &affected_rows,
|
||||
ObInsertMonitor *insert_monitor = NULL);
|
||||
int fill_lob_sstable_slice(
|
||||
const uint64_t table_id,
|
||||
ObIAllocator &allocator,
|
||||
ObIAllocator &iter_allocator,
|
||||
const share::SCN &start_scn,
|
||||
const ObBatchSliceWriteInfo &info,
|
||||
share::ObTabletCacheInterval &pk_interval,
|
||||
const ObArray<int64_t> &lob_column_idxs,
|
||||
const ObArray<common::ObObjMeta> &col_types,
|
||||
const int64_t lob_inrow_threshold,
|
||||
blocksstable::ObDatumRow &datum_row);
|
||||
int close();
|
||||
int fill_column_group(
|
||||
const ObStorageSchema *storage_schema,
|
||||
const share::SCN &start_scn,
|
||||
ObInsertMonitor *monitor_node = NULL);
|
||||
void set_row_offset(const int64_t row_offset) { row_offset_ = row_offset; }
|
||||
int64_t get_row_count() const { return nullptr == slice_store_ ? 0 : slice_store_->get_row_count(); }
|
||||
int64_t get_row_offset() const { return row_offset_; }
|
||||
bool is_empty() const { return 0 == get_row_count(); }
|
||||
bool need_column_store() const { return need_column_store_; }
|
||||
ObTabletSliceStore *get_slice_store() const { return slice_store_; }
|
||||
void cancel() { ATOMIC_SET(&is_canceled_, true); }
|
||||
TO_STRING_KV(K(is_inited_), K(need_column_store_), K(is_canceled_), K(start_seq_), KPC(slice_store_), K(row_offset_));
|
||||
private:
|
||||
int fill_lob_into_memtable( // for version < 4.3.0.0
|
||||
ObIAllocator &allocator,
|
||||
const ObBatchSliceWriteInfo &info,
|
||||
const ObArray<int64_t> &lob_column_idxs,
|
||||
const ObArray<common::ObObjMeta> &col_types,
|
||||
const int64_t lob_inrow_threshold,
|
||||
blocksstable::ObDatumRow &datum_row);
|
||||
int fill_lob_into_macro_block( // for version >= 4.3.0.0
|
||||
ObIAllocator &allocator,
|
||||
ObIAllocator &iter_allocator,
|
||||
const share::SCN &start_scn,
|
||||
const ObBatchSliceWriteInfo &info,
|
||||
share::ObTabletCacheInterval &pk_interval,
|
||||
const ObArray<int64_t> &lob_column_idxs,
|
||||
const ObArray<common::ObObjMeta> &col_types,
|
||||
const int64_t lob_inrow_threshold,
|
||||
blocksstable::ObDatumRow &datum_row);
|
||||
|
||||
int check_null(
|
||||
const bool is_index_table,
|
||||
const int64_t rowkey_column_cnt,
|
||||
const blocksstable::ObDatumRow &row_val) const;
|
||||
int prepare_slice_store_if_need(
|
||||
const int64_t schema_rowkey_column_num,
|
||||
const bool is_slice_store,
|
||||
const ObCompressorType compress_type,
|
||||
const share::SCN &start_scn);
|
||||
int report_unique_key_dumplicated(
|
||||
const int ret_code,
|
||||
const uint64_t table_id,
|
||||
const blocksstable::ObDatumRow &datum_row,
|
||||
const common::ObTabletID &tablet_id,
|
||||
int &report_ret_code);
|
||||
int prepare_iters(
|
||||
ObIAllocator &allocator,
|
||||
ObIAllocator &iter_allocator,
|
||||
blocksstable::ObStorageDatum &datum,
|
||||
const share::ObLSID &ls_id,
|
||||
const ObTabletID &tablet_id,
|
||||
const int64_t trans_version,
|
||||
const ObCollationType &cs_type,
|
||||
const ObLobId &lob_id,
|
||||
const transaction::ObTransID trans_id,
|
||||
const int64_t seq_no,
|
||||
const int64_t timeout_ts,
|
||||
const int64_t lob_inrow_threshold,
|
||||
ObLobMetaRowIterator *&row_iter);
|
||||
private:
|
||||
bool is_inited_;
|
||||
bool need_column_store_;
|
||||
bool is_canceled_;
|
||||
blocksstable::ObMacroDataSeq start_seq_;
|
||||
ObTabletDirectLoadMgr *tablet_direct_load_mgr_;
|
||||
ObTabletSliceStore *slice_store_;
|
||||
ObLobMetaWriteIter *meta_write_iter_;
|
||||
ObLobMetaRowIterator *row_iterator_;
|
||||
common::ObArenaAllocator allocator_;
|
||||
int64_t row_offset_;
|
||||
};
|
||||
|
||||
class ObCOSliceWriter
|
||||
{
|
||||
public:
|
||||
ObCOSliceWriter() : is_inited_(false), cg_idx_(-1), cg_schema_(nullptr), data_desc_(true /*is ddl*/) {}
|
||||
~ObCOSliceWriter() {}
|
||||
int init(
|
||||
const ObStorageSchema *storage_schema,
|
||||
const int64_t cg_idx,
|
||||
ObTabletDirectLoadMgr *tablet_direct_load_mgr,
|
||||
const blocksstable::ObMacroDataSeq &start_seq,
|
||||
const int64_t row_id_offset,
|
||||
const share::SCN &start_scn);
|
||||
void reset();
|
||||
int append_row(
|
||||
const sql::ObChunkDatumStore::StoredRow *stored_row);
|
||||
int project_cg_row(
|
||||
const ObStorageColumnGroupSchema &cg_schema,
|
||||
const sql::ObChunkDatumStore::StoredRow *stored_row,
|
||||
blocksstable::ObDatumRow &cg_row);
|
||||
int close();
|
||||
TO_STRING_KV(K(is_inited_), K(cg_idx_), KPC(cg_schema_), K(macro_block_writer_), K(data_desc_), K(cg_row_));
|
||||
private:
|
||||
bool is_inited_;
|
||||
int64_t cg_idx_;
|
||||
const ObStorageColumnGroupSchema *cg_schema_;
|
||||
blocksstable::ObWholeDataStoreDesc data_desc_;
|
||||
blocksstable::ObSSTableIndexBuilder index_builder_;
|
||||
blocksstable::ObMacroBlockWriter macro_block_writer_;
|
||||
storage::ObDDLRedoLogWriter ddl_clog_writer_;
|
||||
storage::ObDDLRedoLogWriterCallback flush_callback_;
|
||||
blocksstable::ObDatumRow cg_row_;
|
||||
};
|
||||
|
||||
struct ObTabletDirectLoadExecContextId final
|
||||
{
|
||||
public:
|
||||
ObTabletDirectLoadExecContextId()
|
||||
: tablet_id_(), context_id_(OB_INVALID_ID)
|
||||
{}
|
||||
~ObTabletDirectLoadExecContextId() = default;
|
||||
uint64_t hash() const {
|
||||
return tablet_id_.hash() + murmurhash(&context_id_, sizeof(context_id_), 0);
|
||||
}
|
||||
int hash(uint64_t &hash_val) const {hash_val = hash(); return OB_SUCCESS;}
|
||||
bool is_valid() const { return context_id_ >= 0; }
|
||||
bool operator == (const ObTabletDirectLoadExecContextId &other) const {
|
||||
return tablet_id_ == other.tablet_id_ && context_id_ == other.context_id_; }
|
||||
TO_STRING_KV(K_(tablet_id), K_(context_id));
|
||||
public:
|
||||
common::ObTabletID tablet_id_;
|
||||
int64_t context_id_;
|
||||
};
|
||||
|
||||
struct ObTabletDirectLoadExecContext final
|
||||
{
|
||||
public:
|
||||
ObTabletDirectLoadExecContext()
|
||||
: start_scn_(), execution_id_(0), seq_interval_task_id_(0)
|
||||
{}
|
||||
~ObTabletDirectLoadExecContext() = default;
|
||||
TO_STRING_KV(K_(start_scn), K_(execution_id), K_(seq_interval_task_id));
|
||||
public:
|
||||
share::SCN start_scn_;
|
||||
int64_t execution_id_;
|
||||
int64_t seq_interval_task_id_;
|
||||
};
|
||||
|
||||
}// namespace storage
|
||||
}// namespace oceanbase
|
||||
|
||||
#endif//OCEANBASE_STORAGE_OB_DIRECT_LOAD_COMMON_H
|
||||
Reference in New Issue
Block a user