hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
aeeef83dac8d653e792fda8505bd1cb6b05f74e9
oceanbase/src/storage/ob_i_table.h

599 lines
23 KiB
C++
Raw Blame History

/**
* 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 SRC_STORAGE_OB_I_TABLE_H_
#define SRC_STORAGE_OB_I_TABLE_H_
#include "common/ob_range.h"
#include "lib/allocator/ob_allocator.h"
#include "lib/atomic/ob_atomic.h"
#include "lib/container/ob_iarray.h"
#include "lib/container/ob_se_array_iterator.h"
#include "lib/hash/ob_hashmap.h"
#include "lib/lock/ob_drw_lock.h"
#include "lib/oblog/ob_log_module.h"
#include "storage/ob_i_store.h"
#include "storage/access/ob_table_read_info.h"
#include "storage/meta_mem/ob_tenant_meta_obj_pool.h"
#include "storage/meta_mem/ob_storage_meta_cache.h"
#include "share/ob_table_range.h"
#include "share/scn.h"
namespace oceanbase
{
namespace memtable
{
class ObMemtable;
class ObIMemtable;
}
namespace transaction
{
namespace tablelock
{
class ObLockMemtable;
}
}
namespace blocksstable
{
struct ObDatumRowkey;
struct ObDatumRange;
class ObSSTable;
}
namespace share
{
struct ObScnRange;
}
namespace storage
{
class ObTxDataMemtable;
class ObTxCtxMemtable;
class ObLSMemberMemtable;
class ObTenantMetaMemMgr;
struct ObTableIterParam;
struct ObTableAccessParam;
struct ObTableAccessContext;
struct ObRowsInfo;
class ObStoreRowIterator;
struct ObStoreCtx;
class ObITable
{
OB_UNIS_VERSION_V(1);
public:
// Attention! keep update with table_types in GV$OB_SSTABLES
enum TableType : unsigned char
{
// < memtable start from here
DATA_MEMTABLE = 0,
TX_DATA_MEMTABLE = 1,
TX_CTX_MEMTABLE = 2,
LOCK_MEMTABLE = 3,
// < add new memtable here
// < sstable start from here
MAJOR_SSTABLE = 10, //Reuse type, also represents row store column group in column store
MINOR_SSTABLE = 11,
MINI_SSTABLE = 12,
META_MAJOR_SSTABLE = 13,
DDL_DUMP_SSTABLE = 14,
REMOTE_LOGICAL_MINOR_SSTABLE = 15,
DDL_MEM_SSTABLE = 16,
COLUMN_ORIENTED_SSTABLE = 17,
NORMAL_COLUMN_GROUP_SSTABLE = 18,
ROWKEY_COLUMN_GROUP_SSTABLE = 19,
COLUMN_ORIENTED_META_SSTABLE = 20,
DDL_MERGE_CO_SSTABLE = 21, // used for column store ddl, for base sstable
DDL_MERGE_CG_SSTABLE = 22, // used for column store ddl, for normal cg sstable, rowkey cg not supported
DDL_MEM_CO_SSTABLE = 23,
DDL_MEM_CG_SSTABLE = 24,
// < add new sstable before here, See is_sstable()
MAX_TABLE_TYPE
};
OB_INLINE static bool is_table_type_valid(const TableType &type);
struct TableKey
{
OB_UNIS_VERSION(1);
public:
TableKey();
uint64_t hash() const;
int hash(uint64_t &hash_val) const { hash_val = hash(); return OB_SUCCESS; }
void reset();
OB_INLINE bool is_valid() const;
OB_INLINE bool operator ==(const TableKey &table_key) const;
OB_INLINE bool operator !=(const TableKey &table_key) const;
// table type interfaces
OB_INLINE bool is_memtable() const { return ObITable::is_memtable(table_type_); }
OB_INLINE bool is_resident_memtable() const { return ObITable::is_resident_memtable(table_type_); }
OB_INLINE bool is_data_memtable() const { return ObITable::is_data_memtable(table_type_); }
OB_INLINE bool is_tx_data_memtable() const { return ObITable::is_tx_data_memtable(table_type_); }
OB_INLINE bool is_tx_ctx_memtable() const { return ObITable::is_tx_ctx_memtable(table_type_); }
OB_INLINE bool is_lock_memtable() const { return ObITable::is_lock_memtable(table_type_); }
OB_INLINE bool is_minor_sstable() const { return ObITable::is_minor_sstable(table_type_); }
OB_INLINE bool is_mini_sstable() const { return ObITable::is_mini_sstable(table_type_); }
OB_INLINE bool is_major_sstable() const { return ObITable::is_major_sstable(table_type_) || ObITable::is_meta_major_sstable(table_type_); }
OB_INLINE bool is_major_or_ddl_merge_sstable() const { return is_major_sstable() || ObITable::is_ddl_merge_sstable(table_type_); }
OB_INLINE bool is_ddl_merge_sstable() const { return ObITable::is_ddl_merge_sstable(table_type_); }
OB_INLINE bool is_ddl_mem_co_cg_sstable() const { return ObITable::is_ddl_mem_co_cg_sstable(table_type_); }
OB_INLINE bool is_meta_major_sstable() const { return ObITable::is_meta_major_sstable(table_type_); }
OB_INLINE bool is_multi_version_table() const { return ObITable::is_multi_version_table(table_type_); }
OB_INLINE bool is_ddl_sstable() const { return ObITable::is_ddl_sstable(table_type_); }
OB_INLINE bool is_ddl_dump_sstable() const { return ObITable::is_ddl_dump_sstable(table_type_); }
OB_INLINE bool is_ddl_mem_sstable() const { return ObITable::is_ddl_mem_sstable(table_type_); }
OB_INLINE bool is_table_with_scn_range() const { return ObITable::is_table_with_scn_range(table_type_); }
OB_INLINE bool is_remote_logical_minor_sstable() const { return ObITable::is_remote_logical_minor_sstable(table_type_); }
OB_INLINE bool is_co_sstable() const { return ObITable::is_co_sstable(table_type_); }
OB_INLINE bool is_rowkey_cg_sstable() const { return ObITable::is_rowkey_cg_sstable(table_type_); }
OB_INLINE bool is_normal_cg_sstable() const { return ObITable::is_normal_cg_sstable(table_type_); }
OB_INLINE bool is_cg_sstable() const { return ObITable::is_cg_sstable(table_type_); }
OB_INLINE bool is_column_store_sstable() const { return is_co_sstable() || is_cg_sstable(); }
OB_INLINE const common::ObTabletID &get_tablet_id() const { return tablet_id_; }
OB_INLINE share::SCN get_start_scn() const { return scn_range_.start_scn_; }
OB_INLINE share::SCN get_end_scn() const { return scn_range_.end_scn_; }
OB_INLINE int64_t get_snapshot_version() const
{
return version_range_.snapshot_version_;
}
OB_INLINE uint16_t get_column_group_id() const { return column_group_idx_; }
OB_INLINE TableKey& operator=(const TableKey &key)
{
table_type_ = key.table_type_;
tablet_id_ = key.tablet_id_;
scn_range_ = key.scn_range_;
column_group_idx_ = key.column_group_idx_;
return *this;
}
TO_STRING_KV(K_(tablet_id), K_(column_group_idx), "table_type", get_table_type_name(table_type_), K_(scn_range));
public:
common::ObTabletID tablet_id_;
union {
common::ObNewVersionRange version_range_;
share::ObScnRange scn_range_;
};
uint16_t column_group_idx_;
ObITable::TableType table_type_;
};
ObITable();
virtual ~ObITable() {}
int init(const TableKey &table_key);
void reset();
virtual int safe_to_destroy(bool &is_safe);
OB_INLINE const TableKey &get_key() const { return key_; }
void set_scn_range(share::ObScnRange scn_range) { key_.scn_range_ = scn_range; }
void set_table_type(ObITable::TableType table_type) { key_.table_type_ = table_type; }
void set_snapshot_version(int64_t version) { key_.version_range_.snapshot_version_ = version; }
virtual int exist(
ObStoreCtx &ctx,
const uint64_t table_id,
const storage::ObITableReadInfo &read_info,
const blocksstable::ObDatumRowkey &rowkey,
bool &is_exist,
bool &has_found);
virtual int exist(
const ObTableIterParam &param,
ObTableAccessContext &context,
const blocksstable::ObDatumRowkey &rowkey,
bool &is_exist,
bool &has_found);
virtual int exist(
ObRowsInfo &rowsInfo,
bool &is_exist,
bool &has_found);
virtual int scan(
const ObTableIterParam &param,
ObTableAccessContext &context,
const blocksstable::ObDatumRange &key_range,
ObStoreRowIterator *&row_iter) = 0;
virtual int get(
const storage::ObTableIterParam &param,
storage::ObTableAccessContext &context,
const blocksstable::ObDatumRowkey &rowkey,
ObStoreRowIterator *&row_iter) = 0;
virtual int multi_get(
const ObTableIterParam &param,
ObTableAccessContext &context,
const common::ObIArray<blocksstable::ObDatumRowkey> &rowkeys,
ObStoreRowIterator *&row_iter) = 0;
virtual int multi_scan(
const ObTableIterParam &param,
ObTableAccessContext &context,
const common::ObIArray<blocksstable::ObDatumRange> &ranges,
ObStoreRowIterator *&row_iter) = 0;
virtual OB_INLINE share::SCN get_start_scn() const;
virtual OB_INLINE share::SCN get_end_scn() const;
virtual OB_INLINE share::ObScnRange &get_scn_range() { return key_.scn_range_; }
virtual OB_INLINE bool is_trans_state_deterministic() { return get_upper_trans_version() < INT64_MAX; }
virtual int64_t get_snapshot_version() const { return key_.get_snapshot_version(); }
virtual int64_t get_upper_trans_version() const { return get_snapshot_version(); }
virtual int64_t get_max_merged_trans_version() const { return get_snapshot_version(); }
virtual int get_frozen_schema_version(int64_t &schema_version) const = 0;
OB_INLINE uint16_t get_column_group_id() const { return key_.get_column_group_id(); }
virtual void inc_ref();
virtual int64_t dec_ref();
virtual int64_t get_ref() const { return ATOMIC_LOAD(&ref_cnt_); }
// TODO @hanhui so many table type judgement
virtual bool is_sstable() const { return is_sstable(key_.table_type_); }
virtual bool is_co_sstable() const { return is_co_sstable(key_.table_type_); }
virtual bool is_rowkey_cg_sstable() const { return is_rowkey_cg_sstable(key_.table_type_); }
virtual bool is_normal_cg_sstable() const { return is_normal_cg_sstable(key_.table_type_); }
virtual bool is_cg_sstable() const { return is_cg_sstable(key_.table_type_); }
virtual bool is_column_store_sstable() const { return is_co_sstable() || is_cg_sstable(); }
virtual bool is_meta_major_sstable() const { return is_meta_major_sstable(key_.table_type_); }
virtual bool is_major_sstable() const { return is_major_sstable(key_.table_type_) || is_meta_major_sstable(key_.table_type_); }
virtual bool is_major_or_ddl_merge_sstable() const { return is_major_sstable() || is_ddl_merge_sstable(key_.table_type_); }
virtual bool is_minor_sstable() const { return is_minor_sstable(key_.table_type_); }
virtual bool is_mini_sstable() const { return is_mini_sstable(key_.table_type_); }
virtual bool is_multi_version_minor_sstable() const { return is_multi_version_minor_sstable(key_.table_type_); }
virtual bool is_multi_version_table() const { return is_multi_version_table(key_.table_type_); }
virtual bool is_memtable() const { return is_memtable(key_.table_type_); }
virtual bool is_resident_memtable() const { return is_resident_memtable(key_.table_type_); }
virtual bool is_data_memtable() const { return is_data_memtable(key_.table_type_); }
virtual bool is_tx_data_memtable() const { return is_tx_data_memtable(key_.table_type_); }
virtual bool is_tx_ctx_memtable() const { return is_tx_ctx_memtable(key_.table_type_); }
virtual bool is_lock_memtable() const { return is_lock_memtable(key_.table_type_); }
virtual bool is_frozen_memtable() const { return false; }
virtual bool is_active_memtable() const { return false; }
OB_INLINE bool is_table_with_scn_range() const { return is_table_with_scn_range(key_.table_type_); }
virtual OB_INLINE int64_t get_timestamp() const { return 0; }
virtual bool is_ddl_sstable() const { return is_ddl_sstable(key_.table_type_); }
virtual bool is_ddl_dump_sstable() const { return is_ddl_dump_sstable(key_.table_type_); }
virtual bool is_ddl_mem_sstable() const { return is_ddl_mem_sstable(key_.table_type_); }
virtual bool is_ddl_merge_sstable() const { return is_ddl_merge_sstable(key_.table_type_); }
virtual bool is_ddl_mem_co_cg_sstable() const { return is_ddl_mem_co_cg_sstable(key_.table_type_); }
virtual bool is_remote_logical_minor_sstable() const { return is_remote_logical_minor_sstable(key_.table_type_); }
virtual bool is_empty() const = 0;
virtual bool no_data_to_read() const { return is_empty(); }
virtual bool is_ddl_merge_empty_sstable() const { return is_empty() && is_ddl_merge_sstable(); }
DECLARE_VIRTUAL_TO_STRING;
static bool is_sstable(const TableType table_type)
{
return ObITable::MAJOR_SSTABLE <= table_type && table_type < ObITable::MAX_TABLE_TYPE;
}
static bool is_major_sstable(const TableType table_type)
{
return ObITable::TableType::MAJOR_SSTABLE == table_type
|| ObITable::TableType::COLUMN_ORIENTED_SSTABLE == table_type
|| ObITable::TableType::NORMAL_COLUMN_GROUP_SSTABLE == table_type
|| ObITable::TableType::ROWKEY_COLUMN_GROUP_SSTABLE == table_type;
}
static bool is_minor_sstable(const TableType table_type)
{
return ObITable::TableType::MINOR_SSTABLE == table_type
|| ObITable::TableType::MINI_SSTABLE == table_type
|| ObITable::TableType::REMOTE_LOGICAL_MINOR_SSTABLE == table_type;
}
static bool is_multi_version_minor_sstable(const TableType table_type)
{
return ObITable::TableType::MINOR_SSTABLE == table_type
|| ObITable::TableType::MINI_SSTABLE == table_type
|| ObITable::TableType::REMOTE_LOGICAL_MINOR_SSTABLE == table_type;
}
static bool is_multi_version_table(const TableType table_type)
{
// Note (yanyuan.cxf) why we need TX_CTX_MEMTABLE and TX_DATA_MEMTABLE
return ObITable::TableType::DATA_MEMTABLE == table_type
|| ObITable::TableType::TX_CTX_MEMTABLE == table_type
|| ObITable::TableType::TX_DATA_MEMTABLE == table_type
|| ObITable::TableType::LOCK_MEMTABLE == table_type
|| is_multi_version_minor_sstable(table_type);
}
static bool is_mini_sstable(const TableType table_type)
{
return ObITable::TableType::MINI_SSTABLE == table_type;
}
/*
*column store sstables
*/
static bool is_co_sstable(const TableType table_type)
{
return ObITable::TableType::COLUMN_ORIENTED_SSTABLE == table_type
|| ObITable::TableType::COLUMN_ORIENTED_META_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CO_SSTABLE == table_type;
}
static bool is_normal_cg_sstable(const TableType table_type)
{
return ObITable::TableType::NORMAL_COLUMN_GROUP_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CG_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_CG_SSTABLE == table_type;
}
static bool is_rowkey_cg_sstable(const TableType table_type)
{
return ObITable::TableType::ROWKEY_COLUMN_GROUP_SSTABLE == table_type;
}
static bool is_cg_sstable(const TableType table_type)
{
return is_normal_cg_sstable(table_type)
|| is_rowkey_cg_sstable(table_type);
}
static bool is_column_store_sstable(const TableType table_type)
{
return is_co_sstable(table_type)
|| is_cg_sstable(table_type)
|| ObITable::TableType::DDL_MEM_CO_SSTABLE == table_type;
}
static bool is_remote_logical_minor_sstable(const TableType table_type)
{
return ObITable::TableType::REMOTE_LOGICAL_MINOR_SSTABLE == table_type;
}
static bool is_memtable(const TableType table_type)
{
// TODO: yanyuan.cxf maybe we need > and <
return (ObITable::TableType::TX_DATA_MEMTABLE == table_type
|| ObITable::TableType::TX_CTX_MEMTABLE == table_type
|| ObITable::TableType::DATA_MEMTABLE == table_type
|| ObITable::TableType::LOCK_MEMTABLE == table_type);
}
static bool is_resident_memtable(const TableType table_type)
{
return (ObITable::TableType::TX_CTX_MEMTABLE == table_type
|| ObITable::TableType::LOCK_MEMTABLE == table_type);
}
static bool is_data_memtable(const TableType table_type)
{
return ObITable::TableType::DATA_MEMTABLE == table_type;
}
static bool is_tx_data_memtable(const TableType table_type)
{
return ObITable::TableType::TX_DATA_MEMTABLE == table_type;
}
static bool is_tx_ctx_memtable(const TableType table_type)
{
return ObITable::TableType::TX_CTX_MEMTABLE == table_type;
}
static bool is_lock_memtable(const TableType table_type)
{
return ObITable::TableType::LOCK_MEMTABLE == table_type;
}
static bool is_meta_major_sstable(const TableType table_type)
{
return ObITable::TableType::META_MAJOR_SSTABLE == table_type
|| ObITable::TableType::COLUMN_ORIENTED_META_SSTABLE == table_type;
}
static bool is_ddl_sstable(const TableType table_type)
{
return ObITable::TableType::DDL_DUMP_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CO_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CG_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_CO_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_CG_SSTABLE == table_type;
}
static bool is_ddl_dump_sstable(const TableType table_type)
{
return ObITable::TableType::DDL_DUMP_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CO_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CG_SSTABLE == table_type;
}
static bool is_ddl_mem_sstable(const TableType table_type)
{
return ObITable::TableType::DDL_MEM_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_CO_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_CG_SSTABLE == table_type;
}
static bool is_ddl_merge_sstable(const TableType table_type)
{
return ObITable::TableType::DDL_MERGE_CO_SSTABLE == table_type
|| ObITable::TableType::DDL_MERGE_CG_SSTABLE == table_type;
}
static bool is_ddl_mem_co_cg_sstable(const TableType table_type)
{
return ObITable::TableType::DDL_MEM_CG_SSTABLE == table_type
|| ObITable::TableType::DDL_MEM_CO_SSTABLE == table_type;
}
static bool is_table_with_scn_range(const TableType table_type)
{
return is_multi_version_table(table_type) || is_meta_major_sstable(table_type);
}
OB_INLINE static const char* get_table_type_name(const TableType &table_type)
{
return is_table_type_valid(table_type) ? table_type_name_[table_type] : nullptr;
}
protected:
TableKey key_;
int64_t ref_cnt_;
private:
const static char * table_type_name_[];
DISALLOW_COPY_AND_ASSIGN(ObITable);
};
inline void ObITable::inc_ref()
{
int64_t cnt = ATOMIC_AAF(&ref_cnt_, 1);
STORAGE_LOG(DEBUG, "table inc ref", KP(this), "table_key", key_, "ref_cnt", cnt, K(lbt()));
}
inline int64_t ObITable::dec_ref()
{
int64_t cnt = ATOMIC_SAF(&ref_cnt_, 1 /* just sub 1 */);
STORAGE_LOG(DEBUG, "table dec ref", KP(this), "table_key", key_, "ref_cnt", cnt, K(lbt()));
return cnt;
}
class ObTableHandleV2 final
{
friend class ObTablesHandleArray;
public:
ObTableHandleV2();
~ObTableHandleV2();
bool is_valid() const;
void reset();
OB_INLINE ObITable *get_table() { return table_; }
OB_INLINE const ObITable *get_table() const { return table_; }
OB_INLINE common::ObIAllocator *get_allocator() { return allocator_; }
int get_sstable(blocksstable::ObSSTable *&sstable);
int get_sstable(const blocksstable::ObSSTable *&sstable) const;
int get_memtable(memtable::ObIMemtable *&memtable);
int get_memtable(const memtable::ObIMemtable *&memtable) const;
int get_data_memtable(memtable::ObMemtable *&memtable);
int get_data_memtable(const memtable::ObMemtable *&memtable) const;
int get_tx_data_memtable(ObTxDataMemtable *&memtable);
int get_tx_data_memtable(const ObTxDataMemtable *&memtable) const;
int get_tx_ctx_memtable(ObTxCtxMemtable *&memtable);
int get_tx_ctx_memtable(const ObTxCtxMemtable *&memtable) const;
int get_lock_memtable(transaction::tablelock::ObLockMemtable *&memtable);
int get_lock_memtable(const transaction::tablelock::ObLockMemtable *&memtable) const;
ObTableHandleV2(const ObTableHandleV2 &other);
ObTableHandleV2 &operator= (const ObTableHandleV2 &other);
int set_table(ObITable *const table, ObTenantMetaMemMgr *const t3m, const ObITable::TableType table_type);
// TODO: simplify set_sstable interfaces
// only used when create stand alone sstable
int set_sstable(ObITable *table, common::ObIAllocator *allocator);
// set sstable when lifetime is guaranteed by tablet
int set_sstable_with_tablet(ObITable *table);
int set_sstable(ObITable *table, const ObStorageMetaHandle &meta_handle);
TO_STRING_KV(KP_(table), KP(t3m_), KP(allocator_), K(table_type_),
K_(meta_handle), K_(lifetime_guaranteed_by_tablet));
private:
ObITable *table_;
ObTenantMetaMemMgr *t3m_;
common::ObIAllocator *allocator_;
ObStorageMetaHandle meta_handle_;
ObITable::TableType table_type_;
bool lifetime_guaranteed_by_tablet_;
};
class ObTablesHandleArray final
{
public:
typedef common::ObArray<storage::ObTableHandleV2> HandlesArray;
ObTablesHandleArray();
ObTablesHandleArray(const uint64_t tenant_id);
~ObTablesHandleArray();
void reset();
OB_INLINE bool empty() const { return handles_array_.empty(); }
OB_INLINE int64_t get_count() const { return handles_array_.count(); }
OB_INLINE ObITable *get_table(const int64_t idx) const
{
return (idx < 0 || idx >= handles_array_.count()) ? nullptr : handles_array_.at(idx).table_;
}
int get_table(const int64_t idx, ObTableHandleV2 &table_handle) const;
int get_table(const ObITable::TableKey &table_key, ObTableHandleV2 &table_handle) const;
// TODO: simplify this add_sstable interface
int add_sstable(ObITable *table, const ObStorageMetaHandle &meta_handle);
int add_memtable(ObITable *table);
int add_table(const ObTableHandleV2 &handle);
int assign(const ObTablesHandleArray &other);
int get_tables(common::ObIArray<ObITable *> &tables) const;
int get_first_memtable(memtable::ObIMemtable *&memtable) const;
int get_all_minor_sstables(common::ObIArray<ObITable *> &tables) const;
int check_continues(const share::ObScnRange *scn_range) const;
DECLARE_TO_STRING;
private:
int tablet_id_check(const common::ObTabletID &tablet_id);
private:
common::ObTabletID tablet_id_;
HandlesArray handles_array_;
DISALLOW_COPY_AND_ASSIGN(ObTablesHandleArray);
};
OB_INLINE bool ObITable::is_table_type_valid(const TableType &type)
{
return (type >= ObITable::DATA_MEMTABLE && type <= ObITable::LOCK_MEMTABLE)
|| (type >= ObITable::MAJOR_SSTABLE && type < ObITable::MAX_TABLE_TYPE);
}
OB_INLINE bool ObITable::TableKey::is_valid() const
{
bool valid = true;
if (!ObITable::is_table_type_valid(table_type_)) {
valid = false;
} else if (!tablet_id_.is_valid()) {
valid = false;
} else if (ObITable::is_table_with_scn_range(table_type_)
&& !scn_range_.is_valid()) {
valid = false;
} else if (ObITable::is_major_sstable(table_type_)
&& !version_range_.is_valid()) {
valid = false;
}
return valid;
}
OB_INLINE share::SCN ObITable::get_start_scn() const
{
return key_.get_start_scn();
}
OB_INLINE share::SCN ObITable::get_end_scn() const
{
return key_.get_end_scn();
}
bool ObITable::TableKey::operator ==(const TableKey &table_key) const
{
bool bret = table_type_ == table_key.table_type_
&& column_group_idx_ == table_key.column_group_idx_
&& tablet_id_ == table_key.tablet_id_
&& scn_range_ == table_key.scn_range_;
return bret;
}
bool ObITable::TableKey::operator !=(const TableKey &table_key) const
{
return !(this->operator ==(table_key));
}
}//storage
}//oceanbase
#endif /* SRC_STORAGE_OB_I_TABLE_H_ */
Reference in New Issue View Git Blame Copy Permalink