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

Remove warning configurations

Browse Source
This commit is contained in:
LINxiansheng 2021-07-30 14:12:13 +08:00 committed by wangzelin.wzl
parent 62c4fec8b5
commit a331dec52c
107 changed files with 695 additions and 693 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
deps/oblib/src/CMakeLists.txt vendored
View File

@ -18,7 +18,8 @@ if (OB_USE_CLANG)
-Wall -Wextra -Wformat -Wno-deprecated
-fno-omit-frame-pointer ${MARCH_CFLAGS} ${MTUNE_CFLAGS}
-Wno-address-of-packed-member -Wno-sign-compare -Werror
-Wno-inconsistent-missing-override -fno-delete-null-pointer-checks
-Wno-inconsistent-missing-override
-fno-delete-null-pointer-checks
-Wno-delete-non-virtual-dtor -Wno-dynamic-class-memaccess
-Wno-format-security -Wno-reserved-user-defined-literal -Wno-sometimes-uninitialized
-Wno-unused-value -Wno-self-assign -Wno-overloaded-virtual

5
src/clog/ob_clog_file_writer.h
View File

@ -131,8 +131,9 @@ public:
destroy();
}
virtual int init(const char* log_dir, const uint32_t align_size, const common::ObILogFileStore* file_store) override;
virtual void destroy();
virtual int init(const char *log_dir,
const uint32_t align_size, const common::ObILogFileStore *file_store) override;
virtual void destroy() override;
virtual int load_file(uint32_t& file_id, uint32_t& offset, bool enable_pre_creation = false) override;
// Local disk format:

96
src/clog/ob_clog_mgr.h
View File

@ -310,75 +310,75 @@ public:
public:
virtual int init(storage::ObPartitionService* partition_service, ObLogReplayEngineWrapper* replay_engine,
election::ObIElectionMgr* election_mgr, const common::ObAddr& self_addr, obrpc::ObBatchRpc* batch_rpc,
obrpc::ObLogRpcProxy* rpc, common::ObMySQLProxy* sql_proxy, const CLogMgrConfig& config);
void destroy();
obrpc::ObLogRpcProxy* rpc, common::ObMySQLProxy* sql_proxy, const CLogMgrConfig& config) override;
void destroy() override;
virtual int create_partition(const common::ObPartitionKey& partition_key, const int64_t replica_num,
const common::ObMemberList& member_list, const common::ObAddr& leader, const int64_t lease_start,
const common::ObVersion& freeze_version, const common::ObReplicaType replica_type,
const common::ObReplicaProperty replica_property, const int64_t last_submit_timestamp,
const uint64_t last_replay_log_id, const int16_t archive_restore_state, const bool need_skip_mlist_check,
ObIPartitionLogService* pls);
ObIPartitionLogService* pls) override;
virtual int assign_partition(const common::ObPartitionKey& partition_key, const ObReplicaType replica_type,
const common::ObReplicaProperty replica_property, const common::ObBaseStorageInfo& info,
const common::ObVersion& freeze_version, const int16_t archive_restore_state, ObIPartitionLogService* pls);
const common::ObVersion& freeze_version, const int16_t archive_restore_state, ObIPartitionLogService* pls) override;
virtual int add_partition(const common::ObPartitionKey& partition_key, const ObReplicaType replica_type,
const common::ObReplicaProperty replica_property, const common::ObBaseStorageInfo& info,
const common::ObVersion& freeze_version, const ObAddr& src_server, const int16_t archive_restore_state,
ObIPartitionLogService* pls);
virtual int handle_packet(int pcode, const char* data, int64_t len);
virtual int run_check_log_file_collect_task();
ObIPartitionLogService* pls) override;
virtual int handle_packet(int pcode, const char* data, int64_t len) override;
virtual int run_check_log_file_collect_task() override;
virtual int req_start_log_id_by_ts(
const obrpc::ObLogReqStartLogIdByTsRequest& req_msg, obrpc::ObLogReqStartLogIdByTsResponse& result);
const obrpc::ObLogReqStartLogIdByTsRequest& req_msg, obrpc::ObLogReqStartLogIdByTsResponse& result) override;
virtual int req_start_pos_by_log_id(
const obrpc::ObLogReqStartPosByLogIdRequest& req_msg, obrpc::ObLogReqStartPosByLogIdResponse& result);
const obrpc::ObLogReqStartPosByLogIdRequest& req_msg, obrpc::ObLogReqStartPosByLogIdResponse& result) override;
virtual int fetch_log(
const obrpc::ObLogExternalFetchLogRequest& req_msg, obrpc::ObLogExternalFetchLogResponse& result);
const obrpc::ObLogExternalFetchLogRequest& req_msg, obrpc::ObLogExternalFetchLogResponse& result) override;
virtual int req_heartbeat_info(
const obrpc::ObLogReqHeartbeatInfoRequest& req_msg, obrpc::ObLogReqHeartbeatInfoResponse& result);
const obrpc::ObLogReqHeartbeatInfoRequest& req_msg, obrpc::ObLogReqHeartbeatInfoResponse& result) override;
virtual int req_start_log_id_by_ts_with_breakpoint(const obrpc::ObLogReqStartLogIdByTsRequestWithBreakpoint& req_msg,
obrpc::ObLogReqStartLogIdByTsResponseWithBreakpoint& result);
obrpc::ObLogReqStartLogIdByTsResponseWithBreakpoint& result) override;
virtual int req_start_pos_by_log_id_with_breakpoint(
const obrpc::ObLogReqStartPosByLogIdRequestWithBreakpoint& req_msg,
obrpc::ObLogReqStartPosByLogIdResponseWithBreakpoint& result);
obrpc::ObLogReqStartPosByLogIdResponseWithBreakpoint& result) override;
virtual int handle_get_mc_ts_request(
const obrpc::ObLogGetMCTsRequest& request_msg, obrpc::ObLogGetMCTsResponse& result);
const obrpc::ObLogGetMCTsRequest& request_msg, obrpc::ObLogGetMCTsResponse& result) override;
virtual int handle_get_mc_ctx_array_request(
const obrpc::ObLogGetMcCtxArrayRequest& request_msg, obrpc::ObLogGetMcCtxArrayResponse& result);
const obrpc::ObLogGetMcCtxArrayRequest& request_msg, obrpc::ObLogGetMcCtxArrayResponse& result) override;
virtual int handle_get_priority_array_request(
const obrpc::ObLogGetPriorityArrayRequest& request_msg, obrpc::ObLogGetPriorityArrayResponse& result);
const obrpc::ObLogGetPriorityArrayRequest& request_msg, obrpc::ObLogGetPriorityArrayResponse& result) override;
ObLogExecutor& get_log_executor()
{
return log_executor_;
}
virtual logservice::ObExtLogService* get_external_log_service()
virtual logservice::ObExtLogService* get_external_log_service() override
{
return &external_log_service_;
}
int start();
void stop();
void wait();
bool is_scan_finished() const;
int start() override;
void stop() override;
void wait() override;
bool is_scan_finished() const override;
// for test
int get_last_slide_log_id(const common::ObPartitionKey& partition_key, uint64_t& log_id);
ObILogEngine* get_log_engine()
ObILogEngine* get_log_engine() override
{
return &log_engine_;
}
virtual int get_need_freeze_partition_array(NeedFreezePartitionArray& partition_array) const;
virtual uint32_t get_clog_min_using_file_id() const;
virtual int get_need_freeze_partition_array(NeedFreezePartitionArray& partition_array) const override;
virtual uint32_t get_clog_min_using_file_id() const override;
virtual int get_clog_using_disk_space(int64_t& using_space) const override;
virtual int get_ilog_using_disk_space(int64_t& using_space) const override;
//===================== transaction one phase commit begin ================
public:
virtual int batch_submit_log(const transaction::ObTransID& trans_id, const common::ObPartitionArray& partition_array,
const ObLogInfoArray& log_info_array, const ObISubmitLogCbArray& cb_array);
virtual int check_can_batch_submit(const common::ObPartitionArray& partition_array, bool& can_batch);
virtual int batch_flush_cb(const transaction::ObTransID& trans_id, const ObLogCursor& base_log_cursor);
const ObLogInfoArray& log_info_array, const ObISubmitLogCbArray& cb_array) override;
virtual int check_can_batch_submit(const common::ObPartitionArray& partition_array, bool& can_batch) override;
virtual int batch_flush_cb(const transaction::ObTransID& trans_id, const ObLogCursor& base_log_cursor) override;
virtual int batch_receive_log(const transaction::ObTransID& trans_id, const common::ObPartitionArray& partition_array,
const ObLogInfoArray& log_info_array, const common::ObAddr& leader, const int64_t cluster_id);
const ObLogInfoArray& log_info_array, const common::ObAddr& leader, const int64_t cluster_id) override;
virtual int batch_ack_log(
const transaction::ObTransID& trans_id, const common::ObAddr& server, const ObBatchAckArray& batch_ack_array);
const transaction::ObTransID& trans_id, const common::ObAddr& server, const ObBatchAckArray& batch_ack_array) override;
//===================== transaction one phase commit end ================
// Query the accumulative checksum and submit_timestamp values corresponding to this log_id based on log_id.
@ -400,45 +400,45 @@ public:
// OB_NOT_INIT
// OB_INVALID_ARGUMENT
virtual int query_log_info_with_log_id(const common::ObPartitionKey& partition_key, const uint64_t log_id,
int64_t& accum_checksum, int64_t& submit_timestamp, int64_t& epoch_id);
int64_t& accum_checksum, int64_t& submit_timestamp, int64_t& epoch_id) override;
virtual int query_log_info_with_log_id(const common::ObPartitionKey& partition_key, const uint64_t log_id,
ObLogEntry& log_entry, int64_t& accum_checksum, bool& is_batch_committed);
ObLogEntry& log_entry, int64_t& accum_checksum, bool& is_batch_committed) override;
// **********************************************************
// batch get valid_candidates
virtual int get_candidates_array(const common::ObPartitionIArray& pkey_array,
const common::ObAddrIArray& dst_server_list, common::ObSArray<common::ObAddrSArray>& candidate_mlist_array,
common::ObSArray<obrpc::CandidateStatusList>& status_array) const;
common::ObSArray<obrpc::CandidateStatusList>& status_array) const override;
//===================== batch change member begin ================
public:
virtual int batch_add_member(const obrpc::ObChangeMemberArgs& ctx_array, obrpc::ObChangeMemberCtxs& return_ctx_array);
virtual int batch_add_member(const obrpc::ObChangeMemberArgs& ctx_array, obrpc::ObChangeMemberCtxs& return_ctx_array) override;
virtual int batch_remove_member(
const obrpc::ObChangeMemberArgs& ctx_array, obrpc::ObChangeMemberCtxs& return_ctx_array);
virtual int batch_is_member_change_done(obrpc::ObChangeMemberCtxs& return_ctx_array);
const obrpc::ObChangeMemberArgs& ctx_array, obrpc::ObChangeMemberCtxs& return_ctx_array) override;
virtual int batch_is_member_change_done(obrpc::ObChangeMemberCtxs& return_ctx_array) override;
virtual int batch_add_member(const common::ObPartitionArray& partition_array,
const common::ObMemberArray& member_array, const common::ObQuorumArray& quorum_array,
common::ObReturnArray& ret_array, ObMCLogInfoArray& log_info_array);
common::ObReturnArray& ret_array, ObMCLogInfoArray& log_info_array) override;
virtual int batch_remove_member(const common::ObPartitionArray& partition_array,
const common::ObMemberArray& member_array, const common::ObQuorumArray& quorum_array,
common::ObReturnArray& ret_array, ObMCLogInfoArray& log_info_array);
common::ObReturnArray& ret_array, ObMCLogInfoArray& log_info_array) override;
virtual int batch_is_member_change_done(const common::ObPartitionArray& partition_array,
const ObMCLogInfoArray& log_info_array, common::ObReturnArray& ret_array);
virtual int get_election_group_priority(const uint64_t tenant_id, election::ObElectionGroupPriority& priority) const;
const ObMCLogInfoArray& log_info_array, common::ObReturnArray& ret_array) override;
virtual int get_election_group_priority(const uint64_t tenant_id, election::ObElectionGroupPriority& priority) const override;
virtual int handle_get_remote_log_request(
const obrpc::ObLogGetRemoteLogRequest& request_msg, obrpc::ObLogGetRemoteLogResponse& result);
virtual ObLogCallbackEngine& get_cb_engine()
const obrpc::ObLogGetRemoteLogRequest& request_msg, obrpc::ObLogGetRemoteLogResponse& result) override;
virtual ObLogCallbackEngine& get_cb_engine() override
{
return cb_engine_;
}
// ==================== physical flashback =====================
int delete_all_log_files();
int delete_all_log_files() override;
// ==================== log archive =====================
int add_pg_archive_task(storage::ObIPartitionGroup* partition);
int try_advance_restoring_clog();
int delete_pg_archive_task(storage::ObIPartitionGroup* partition);
int add_pg_archive_task(storage::ObIPartitionGroup* partition) override;
int try_advance_restoring_clog() override;
int delete_pg_archive_task(storage::ObIPartitionGroup* partition) override;
int mark_log_archive_encount_fatal_err(
const common::ObPartitionKey& pkey, const int64_t incarnation, const int64_t archive_round);
int get_archive_pg_map(archive::PGArchiveMap*& map);
bool is_server_archive_stop(const int64_t incarnation, const int64_t archive_round);
const common::ObPartitionKey& pkey, const int64_t incarnation, const int64_t archive_round) override;
int get_archive_pg_map(archive::PGArchiveMap*& map) override;
bool is_server_archive_stop(const int64_t incarnation, const int64_t archive_round) override;
public:
// clog callback thread num

2
src/clog/ob_file_id_cache.cpp
View File

@ -143,7 +143,7 @@ public:
return is_empty_();
}
virtual int search_boundary(const T& item, T& prev_item, T& next_item)
virtual int search_boundary(const T& item, T& prev_item, T& next_item) override
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {

2
src/observer/mysql/obmp_base.h
View File

@ -108,7 +108,7 @@ public:
{
return OB_NOT_NULL(get_conn()) && get_conn()->need_send_extra_ok_packet();
}
virtual int flush_buffer(const bool is_last);
virtual int flush_buffer(const bool is_last) override;
int init(rpc::ObRequest* req, sql::ObSQLSessionInfo* sess_info, uint8_t packet_seq, bool conn_status,
bool req_has_wokenup, int64_t query_receive_ts, bool io_thread_mark);

2
src/observer/ob_inner_sql_connection.h
View File

@ -109,7 +109,7 @@ public:
sql::ObSQLSessionInfo* extern_session = NULL, ObISQLClient* client_addr = NULL,
ObRestoreSQLModifier* sql_modifer = NULL);
int destroy(void);
inline void reset()
inline void reset() override
{
destroy();
}

4
src/observer/ob_inner_sql_connection_pool.h
View File

@ -59,13 +59,13 @@ public:
virtual int wait();
// sql string escape
virtual int escape(const char* from, const int64_t from_size, char* to, const int64_t to_size, int64_t& out_size);
virtual int escape(const char* from, const int64_t from_size, char* to, const int64_t to_size, int64_t& out_size) override;
// acquired connection must be released
virtual int acquire(common::sqlclient::ObISQLConnection*& conn, ObISQLClient* client_addr) override;
virtual int acquire(
common::sqlclient::ObISQLConnection*& conn, const int64_t cluster_id, ObISQLClient* client_addr) override;
virtual int release(common::sqlclient::ObISQLConnection* conn, const bool success);
virtual int release(common::sqlclient::ObISQLConnection* conn, const bool success) override;
int acquire_spi_conn(sql::ObSQLSessionInfo* session_info, observer::ObInnerSQLConnection*& conn);
int acquire(sql::ObSQLSessionInfo* session_info, common::sqlclient::ObISQLConnection*& conn);

104
src/observer/ob_inner_sql_result.h
View File

@ -40,69 +40,69 @@ public:
int init();
virtual int open();
virtual int close();
virtual int next();
virtual int close() override;
virtual int next() override;
int force_close(bool need_retry);
virtual int print_info() const;
virtual int print_info() const override;
virtual int get_int(const int64_t col_idx, int64_t& int_val) const;
virtual int get_uint(const int64_t col_idx, uint64_t& int_val) const;
virtual int get_datetime(const int64_t col_idx, int64_t& datetime) const;
virtual int get_date(const int64_t col_index, int32_t& date) const;
virtual int get_time(const int64_t col_index, int64_t& time) const;
virtual int get_year(const int64_t col_index, uint8_t& year) const;
virtual int get_bool(const int64_t col_idx, bool& bool_val) const;
virtual int get_varchar(const int64_t col_idx, common::ObString& varchar_val) const;
virtual int get_raw(const int64_t col_idx, common::ObString& varchar_val) const;
virtual int get_float(const int64_t col_idx, float& float_val) const;
virtual int get_double(const int64_t col_idx, double& double_val) const;
virtual int get_timestamp(const int64_t col_idx, const common::ObTimeZoneInfo* tz_info, int64_t& timestamp) const;
virtual int get_int(const int64_t col_idx, int64_t& int_val) const override;
virtual int get_uint(const int64_t col_idx, uint64_t& int_val) const override;
virtual int get_datetime(const int64_t col_idx, int64_t& datetime) const override;
virtual int get_date(const int64_t col_index, int32_t& date) const override;
virtual int get_time(const int64_t col_index, int64_t& time) const override;
virtual int get_year(const int64_t col_index, uint8_t& year) const override;
virtual int get_bool(const int64_t col_idx, bool& bool_val) const override;
virtual int get_varchar(const int64_t col_idx, common::ObString& varchar_val) const override;
virtual int get_raw(const int64_t col_idx, common::ObString& varchar_val) const override;
virtual int get_float(const int64_t col_idx, float& float_val) const override;
virtual int get_double(const int64_t col_idx, double& double_val) const override;
virtual int get_timestamp(const int64_t col_idx, const common::ObTimeZoneInfo* tz_info, int64_t& timestamp) const override;
virtual int get_number(const int64_t col_idx, common::number::ObNumber& nmb_val) const override;
virtual int get_otimestamp_value(const int64_t col_idx, const common::ObTimeZoneInfo& tz_info,
const common::ObObjType type, common::ObOTimestampData& otimestamp_val) const;
const common::ObObjType type, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_timestamp_tz(
const int64_t col_idx, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const;
const int64_t col_idx, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_timestamp_ltz(
const int64_t col_idx, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const;
const int64_t col_idx, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_timestamp_nano(
const int64_t col_idx, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const;
const int64_t col_idx, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_type(const int64_t col_idx, ObObjMeta& type) const override;
virtual int get_obj(const int64_t col_idx, ObObj& obj, const common::ObTimeZoneInfo* tz_info = NULL,
common::ObIAllocator* allocator = NULL) const override;
virtual int get_interval_ym(const int64_t col_idx, ObIntervalYMValue& int_val) const;
virtual int get_interval_ds(const int64_t col_idx, ObIntervalDSValue& int_val) const;
virtual int get_nvarchar2(const int64_t col_idx, common::ObString& nvarchar2_val) const;
virtual int get_nchar(const int64_t col_idx, common::ObString& nchar_val) const;
virtual int get_interval_ym(const int64_t col_idx, ObIntervalYMValue& int_val) const override;
virtual int get_interval_ds(const int64_t col_idx, ObIntervalDSValue& int_val) const override;
virtual int get_nvarchar2(const int64_t col_idx, common::ObString& nvarchar2_val) const override;
virtual int get_nchar(const int64_t col_idx, common::ObString& nchar_val) const override;
virtual int get_int(const char* col_name, int64_t& int_val) const;
virtual int get_uint(const char* col_name, uint64_t& int_val) const;
virtual int get_datetime(const char* col_name, int64_t& datetime) const;
virtual int get_date(const char* col_name, int32_t& date) const;
virtual int get_time(const char* col_name, int64_t& time) const;
virtual int get_year(const char* col_name, uint8_t& year) const;
virtual int get_bool(const char* col_name, bool& bool_val) const;
virtual int get_varchar(const char* col_name, common::ObString& varchar_val) const;
virtual int get_raw(const char* col_name, common::ObString& raw_val) const;
virtual int get_float(const char* col_name, float& float_val) const;
virtual int get_double(const char* col_name, double& double_val) const;
virtual int get_timestamp(const char* col_name, const common::ObTimeZoneInfo* tz_info, int64_t& timestamp) const;
virtual int get_int(const char* col_name, int64_t& int_val) const override;
virtual int get_uint(const char* col_name, uint64_t& int_val) const override;
virtual int get_datetime(const char* col_name, int64_t& datetime) const override;
virtual int get_date(const char* col_name, int32_t& date) const override;
virtual int get_time(const char* col_name, int64_t& time) const override;
virtual int get_year(const char* col_name, uint8_t& year) const override;
virtual int get_bool(const char* col_name, bool& bool_val) const override;
virtual int get_varchar(const char* col_name, common::ObString& varchar_val) const override;
virtual int get_raw(const char* col_name, common::ObString& raw_val) const override;
virtual int get_float(const char* col_name, float& float_val) const override;
virtual int get_double(const char* col_name, double& double_val) const override;
virtual int get_timestamp(const char* col_name, const common::ObTimeZoneInfo* tz_info, int64_t& timestamp) const override;
virtual int get_number(const char* col_name, common::number::ObNumber& nmb_val) const override;
virtual int get_otimestamp_value(const char* col_name, const common::ObTimeZoneInfo& tz_info,
const common::ObObjType type, common::ObOTimestampData& otimestamp_val) const;
const common::ObObjType type, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_timestamp_tz(
const char* col_name, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const;
const char* col_name, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_timestamp_ltz(
const char* col_name, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const;
const char* col_name, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_timestamp_nano(
const char* col_name, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const;
const char* col_name, const common::ObTimeZoneInfo& tz_info, common::ObOTimestampData& otimestamp_val) const override;
virtual int get_type(const char* col_name, ObObjMeta& type) const override;
virtual int get_obj(const char* col_name, ObObj& obj) const override;
virtual int get_interval_ym(const char* col_name, common::ObIntervalYMValue& int_val) const;
virtual int get_interval_ds(const char* col_name, common::ObIntervalDSValue& int_val) const;
virtual int get_nvarchar2(const char* col_name, common::ObString& nvarchar2_val) const;
virtual int get_nchar(const char* col_name, common::ObString& nchar_val) const;
virtual int get_interval_ym(const char* col_name, common::ObIntervalYMValue& int_val) const override;
virtual int get_interval_ds(const char* col_name, common::ObIntervalDSValue& int_val) const override;
virtual int get_nvarchar2(const char* col_name, common::ObString& nvarchar2_val) const override;
virtual int get_nchar(const char* col_name, common::ObString& nchar_val) const override;
sql::ObSqlCtx& sql_ctx()
{
@ -132,7 +132,7 @@ public:
}
int get_obj(const int64_t col_idx, const common::ObObj*& obj) const;
const ObNewRow* get_row() const
const ObNewRow* get_row() const override
{
return row_;
};
@ -144,27 +144,27 @@ public:
}
private:
virtual int inner_get_number(const int64_t col_idx, common::number::ObNumber& nmb_val, IAllocator& allocator) const;
virtual int inner_get_number(const int64_t col_idx, common::number::ObNumber& nmb_val, IAllocator& allocator) const override;
virtual int get_number_impl(const int64_t col_idx, common::number::ObNumber& nmb_val) const;
virtual int inner_get_number(const char* col_name, common::number::ObNumber& nmb_val, IAllocator& allocator) const;
virtual int inner_get_number(const char* col_name, common::number::ObNumber& nmb_val, IAllocator& allocator) const override;
virtual int get_number_impl(const char* col_name, common::number::ObNumber& nmb_val) const;
virtual int inner_get_urowid(
const int64_t col_idx, common::ObURowIDData& urowid_data, common::ObIAllocator& allocator) const;
const int64_t col_idx, common::ObURowIDData& urowid_data, common::ObIAllocator& allocator) const override;
virtual int get_urowid_impl(const int64_t col_idx, common::ObURowIDData& urowid_data) const;
virtual int inner_get_urowid(
const char* col_name, common::ObURowIDData& urowid_data, common::ObIAllocator& allocator) const;
const char* col_name, common::ObURowIDData& urowid_data, common::ObIAllocator& allocator) const override;
virtual int get_urowid_impl(const char* col_name, common::ObURowIDData& urowid_data) const;
virtual int get_lob_locator(const int64_t col_idx, ObLobLocator*& lob_locator) const;
virtual int get_lob_locator(const char* col_name, ObLobLocator*& lob_locator) const;
virtual int get_lob_locator(const int64_t col_idx, ObLobLocator*& lob_locator) const override;
virtual int get_lob_locator(const char* col_name, ObLobLocator*& lob_locator) const override;
virtual int inner_get_lob_locator(
const int64_t col_idx, ObLobLocator*& lob_locator, common::ObIAllocator& allocator) const;
const int64_t col_idx, ObLobLocator*& lob_locator, common::ObIAllocator& allocator) const override;
virtual int inner_get_lob_locator(
const char* col_name, ObLobLocator*& lob_locator, common::ObIAllocator& allocator) const;
const char* col_name, ObLobLocator*& lob_locator, common::ObIAllocator& allocator) const override;
virtual int get_lob_locator_impl(const int64_t col_idx, ObLobLocator*& lob_locator) const;
virtual int get_lob_locator_impl(const char* col_name, ObLobLocator*& lob_locator) const;

2
src/observer/ob_service.h
View File

@ -94,7 +94,7 @@ public:
virtual int fill_partition_replica(const common::ObPGKey& pg_key, share::ObPartitionReplica& replica) override;
virtual int fill_partition_replica(storage::ObIPartitionGroup* part, share::ObPartitionReplica& replica);
int get_pg_key(const common::ObPartitionKey& pkey, common::ObPGKey& pg_key) const;
virtual const common::ObAddr& get_self_addr();
virtual const common::ObAddr& get_self_addr() override;
virtual int fill_checksum(const common::ObPartitionKey& pkey, const uint64_t sstable_id, const int sstable_type,
const ObSSTableChecksumUpdateType update_type,
common::ObIArray<share::ObSSTableDataChecksumItem>& data_checksum_items,

8
src/rootserver/backup/ob_backup_auto_delete_expired_backup.h
View File

@ -55,18 +55,18 @@ public:
share::schema::ObMultiVersionSchemaService& schema_service, ObBackupDataClean& backup_data_clean,
share::ObIBackupLeaseService& backup_lease_service);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
void stop();
void stop() override;
void wakeup();
int idle() const;
virtual bool is_working() const
virtual bool is_working() const override
{
return is_working_;
}
int start();
int start() override;
;
private:

6
src/rootserver/backup/ob_root_validate.h
View File

@ -58,12 +58,12 @@ public:
int init(common::ObServerConfig& config, common::ObMySQLProxy& sql_proxy, ObRootBalancer& root_balancer,
ObServerManager& server_manager, ObRebalanceTaskMgr& rebalance_mgr, obrpc::ObSrvRpcProxy& rpc_proxy,
share::ObIBackupLeaseService& backup_lease_service);
int start();
int start() override;
int idle();
void wakeup();
void stop();
void stop() override;
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}

6
src/rootserver/ob_backup_data_clean.h
View File

@ -59,11 +59,11 @@ public:
int init(share::schema::ObMultiVersionSchemaService& schema_service, ObMySQLProxy& sql_proxy,
share::ObIBackupLeaseService& backup_lease_service);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
void stop();
void stop() override;
void wakeup();
int idle() const;
void update_prepare_flag(const bool is_prepare_flag);
@ -73,7 +73,7 @@ public:
{
return is_working_;
}
int start();
int start() override;
share::ObIBackupLeaseService* get_backup_lease_service()
{
return backup_lease_service_;

4
src/rootserver/ob_create_inner_schema_executor.h
View File

@ -37,8 +37,8 @@ public:
explicit ObCreateInnerSchemaTask(ObCreateInnerSchemaExecutor& executor) : executor_(&executor)
{}
virtual ~ObCreateInnerSchemaTask() = default;
virtual int64_t get_deep_copy_size() const;
share::ObAsyncTask* deep_copy(char* buf, const int64_t buf_size) const;
virtual int64_t get_deep_copy_size() const override;
share::ObAsyncTask* deep_copy(char* buf, const int64_t buf_size) const override;
virtual int process() override;
private:

6
src/rootserver/ob_daily_merge_scheduler.h
View File

@ -266,15 +266,15 @@ public:
void wakeup();
int reset_merger_warm_up_duration_time(const int64_t merger_warm_up_duration_time);
void stop();
virtual int blocking_run()
void stop() override;
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
virtual int manual_start_merge(const common::ObZone& zone);
int64_t get_schedule_interval() const;
int64_t get_schedule_interval() const override;
private:
// return OB_CANCELED if stopped.

4
src/rootserver/ob_empty_server_checker.h
View File

@ -72,7 +72,7 @@ public:
virtual ~ObEmptyServerChecker();
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
@ -81,7 +81,7 @@ public:
share::schema::ObMultiVersionSchemaService& schema_service);
virtual void wakeup();
virtual void stop();
virtual void stop() override;
virtual int notify_check();
virtual int pt_sync_finish(const common::ObAddr& server, const int64_t version);

4
src/rootserver/ob_freeze_info_updater.h
View File

@ -23,11 +23,11 @@ public:
~ObFreezeInfoUpdater();
int init(ObFreezeInfoManager& freeze_info_manager);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
int64_t get_schedule_interval() const;
int64_t get_schedule_interval() const override;
private:
int try_gc_snapshot();

8
src/rootserver/ob_global_max_decided_trans_version_mgr.h
View File

@ -41,10 +41,10 @@ public:
int init(obrpc::ObSrvRpcProxy* rpc_proxy, share::ObPartitionTableOperator* pt_operator,
share::schema::ObMultiVersionSchemaService* schema_service, const common::ObAddr& self_addr);
virtual void run3() override;
virtual int start();
virtual void stop();
virtual void wait();
virtual int blocking_run()
virtual int start() override;
virtual void stop() override;
virtual void wait() override;
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}

28
src/rootserver/ob_leader_coordinator.h
View File

@ -278,22 +278,22 @@ public:
ObDailyMergeScheduler& daily_merge_scheduler);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
void wakeup();
void stop();
void stop() override;
// this interface is provided to daily merge, no one else shall invoke it anywhere
virtual int check_daily_merge_switch_leader(
const common::ObIArray<common::ObZone>& zone_list, common::ObIArray<bool>& results);
virtual int coordinate();
const common::ObIArray<common::ObZone>& zone_list, common::ObIArray<bool>& results) override;
virtual int coordinate() override;
virtual int coordinate_tenants(const common::ObArray<common::ObZone>& excluded_zones,
const common::ObIArray<common::ObAddr>& excluded_servers, const common::ObIArray<uint64_t>& tenant_ids,
const bool force = false);
void set_merge_status(bool is_in_merging)
void set_merge_status(bool is_in_merging) override
{
is_in_merging_ = is_in_merging;
}
@ -302,28 +302,28 @@ public:
virtual int coordinate_partition_group(const uint64_t table_id, const int64_t partition_id,
const common::ObIArray<common::ObAddr>& excluded_servers, const common::ObArray<common::ObZone>& excluded_zones);
virtual int start_smooth_coordinate();
virtual int is_doing_smooth_coordinate(bool& is_doing);
virtual int is_last_switch_turn_succ(bool& is_succ);
virtual int start_smooth_coordinate() override;
virtual int is_doing_smooth_coordinate(bool& is_doing) override;
virtual int is_last_switch_turn_succ(bool& is_succ) override;
virtual void signal()
virtual void signal() override
{
wakeup();
}
virtual int get_leader_stat(ServerLeaderStat& leader_stat);
virtual int get_leader_stat(ServerLeaderStat& leader_stat) override;
// for mock test
virtual int get_tenant_ids(common::ObArray<uint64_t>& tenant_ids);
virtual common::ObLatch& get_lock()
virtual common::ObLatch& get_lock() override
{
return lock_;
}
virtual common::ObLatch& get_switch_leader_lock()
virtual common::ObLatch& get_switch_leader_lock() override
{
return switch_leader_lock_;
}
virtual obrpc::ObSrvRpcProxy& get_rpc_proxy()
virtual obrpc::ObSrvRpcProxy& get_rpc_proxy() override
{
return *srv_rpc_proxy_;
}
@ -334,7 +334,7 @@ public:
}
static int get_same_tablegroup_partition_entity_ids(share::schema::ObSchemaGetterGuard& schema_guard,
const uint64_t partition_entity_id, common::ObIArray<uint64_t>& partition_entity_ids);
int64_t get_schedule_interval() const;
int64_t get_schedule_interval() const override;
int get_excluded_zone_array(common::ObIArray<common::ObZone>& excluded_zone_array) const;
int build_zone_region_score_array(const ObZone& primary_zone,
common::ObIArray<share::ObRawPrimaryZoneUtil::ZoneScore>& zone_score_array,

4
src/rootserver/ob_major_freeze_launcher.h
View File

@ -35,11 +35,11 @@ public:
int init(ObRootService& root_service, obrpc::ObCommonRpcProxy& rpc_proxy, common::ObServerConfig& config,
const common::ObAddr& self_addr, ObFreezeInfoManager& freeze_info_manager);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
int64_t get_schedule_interval() const;
int64_t get_schedule_interval() const override;
private:
static const int64_t TRY_LAUNCH_MAJOR_FREEZE_INTERVAL_US = 1000 * 1000; // 1s

4
src/rootserver/ob_partition_spliter.h
View File

@ -64,8 +64,8 @@ public:
share::schema::ObMultiVersionSchemaService* schema_service, ObRootService* root_service);
virtual void run3() override;
void wakeup();
void stop();
virtual int blocking_run()
void stop() override;
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}

6
src/rootserver/ob_rebalance_task_mgr.h
View File

@ -181,11 +181,11 @@ public:
int init(common::ObServerConfig& config, ObRebalanceTaskExecutor& executor);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
void stop();
void stop() override;
// add_task() will never block. Task with no source_ field will be executed immediately.
//
@ -255,7 +255,7 @@ public:
int check_dest_server_has_too_many_partitions(const ObRebalanceTask& task, bool& is_available);
int get_schedule_task(const ObRebalanceTaskInfo& task_info, const ObAddr& dest, common::ObIAllocator& allocator,
ObRebalanceTask*& task);
int64_t get_schedule_interval() const;
int64_t get_schedule_interval() const override;
private:
common::ObThreadCond& get_cond()

8
src/rootserver/ob_root_backup.h
View File

@ -114,22 +114,22 @@ public:
obrpc::ObSrvRpcProxy& rpc_proxy, share::ObIBackupLeaseService& backup_lease_service,
ObRestorePointService& restore_point_service);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
void stop();
void stop() override;
void wakeup();
int idle() const;
int get_lease_time(const uint64_t tenant_id, int64_t& lease_time);
int update_lease_time(const uint64_t tenant_id);
void update_prepare_flag(const bool is_prepare_flag);
bool get_prepare_flag() const;
virtual bool is_working() const
virtual bool is_working() const override
{
return is_working_;
}
int start();
int start() override;
int update_tenant_backup_meta_info(
const common::ObPartitionKey& pkey, const int64_t pg_count, const int64_t partition_count);
int get_tenant_backup_meta_info(ObTenantBackupMetaInfo& meta_info);

8
src/rootserver/ob_root_balancer.h
View File

@ -156,7 +156,7 @@ public:
int alloc_partitions_for_split(const SCHEMA& table, const SCHEMA& new_schema, ObITablePartitionAddr& addr);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
@ -170,7 +170,7 @@ public:
// balance partition's in %tenant_id
virtual int tenant_balance(const uint64_t tenant_id, int64_t& task_cnt);
int check_locality(int64_t& task_cnt);
void stop();
void stop() override;
void wakeup();
bool is_inited() const
@ -183,7 +183,7 @@ public:
}
void set_active();
// return OB_CANCELED if stop, else return OB_SUCCESS
int check_stop() const;
int check_stop() const override;
int idle() const;
int check_tenant_group_config_legality(
common::ObIArray<ObTenantGroupParser::TenantNameGroup>& tenant_groups, bool& legal);
@ -195,7 +195,7 @@ public:
{
return task_mgr_;
}
int64_t get_schedule_interval() const;
int64_t get_schedule_interval() const override;
int refresh_unit_replica_counter(const uint64_t tenant_id);
int create_unit_replica_counter(const uint64_t tenant_id);
int destory_tenant_unit_array();

12
src/rootserver/ob_root_inspection.h
View File

@ -73,7 +73,7 @@ public:
{}
virtual int inspect(bool& passed, const char*& warning_info) override;
virtual const char* get_task_name() const
virtual const char* get_task_name() const override
{
return "tenant_checker";
};
@ -94,7 +94,7 @@ public:
virtual ~ObTableGroupChecker();
int init();
virtual int inspect(bool& passed, const char*& warning_info) override;
virtual const char* get_task_name() const
virtual const char* get_task_name() const override
{
return "tablegroup_checker";
};
@ -131,7 +131,7 @@ public:
virtual ~ObDropTenantChecker()
{}
virtual int inspect(bool& passed, const char*& warning_info) override;
virtual const char* get_task_name() const
virtual const char* get_task_name() const override
{
return "drop_tenant_checker";
}
@ -173,7 +173,7 @@ public:
virtual ~ObForceDropSchemaChecker()
{}
virtual int inspect(bool& passed, const char*& warning_info) override;
virtual const char* get_task_name() const
virtual const char* get_task_name() const override
{
return "drop_schema_checker";
}
@ -281,7 +281,7 @@ public:
virtual ~ObRootInspection();
virtual int inspect(bool& passed, const char*& warning_info) override;
virtual const char* get_task_name() const
virtual const char* get_task_name() const override
{
return "sys_schema_checker";
};
@ -420,7 +420,7 @@ public:
{}
virtual int inspect(bool& passed, const char*& warning_info) override;
virtual const char* get_task_name() const
virtual const char* get_task_name() const override
{
return "primary_checker";
};

2
src/rootserver/ob_rs_gts_monitor.h
View File

@ -423,7 +423,7 @@ public:
int init(common::ObMySQLProxy* sql_proxy);
virtual void run3() override;
void wakeup();
void stop();
void stop() override;
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();

4
src/rootserver/ob_rs_gts_task_mgr.h
View File

@ -78,11 +78,11 @@ public:
int push_task(const ObGtsReplicaTask* task);
virtual void run3() override;
virtual int blocking_run()
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
void stop();
void stop() override;
private:
const static int64_t TASK_QUEUE_LIMIT = 1 << 16;

4
src/rootserver/ob_schema_history_recycler.h
View File

@ -187,8 +187,8 @@ public:
ObZoneManager& zone_manager, common::ObMySQLProxy& sql_proxy, ObServerManager& server_mgr);
virtual void run3() override;
void wakeup();
void stop();
virtual int blocking_run()
void stop() override;
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}

4
src/rootserver/ob_schema_revise_executor.h
View File

@ -34,8 +34,8 @@ public:
explicit ObSchemaReviseTask(ObSchemaReviseExecutor& executor) : executor_(&executor)
{}
virtual ~ObSchemaReviseTask() = default;
virtual int64_t get_deep_copy_size() const;
share::ObAsyncTask* deep_copy(char* buf, const int64_t buf_size) const;
virtual int64_t get_deep_copy_size() const override;
share::ObAsyncTask* deep_copy(char* buf, const int64_t buf_size) const override;
virtual int process() override;
private:

2
src/rootserver/ob_schema_spliter.h
View File

@ -288,7 +288,7 @@ public:
private:
virtual int quick_check(const uint64_t tenant_id, bool& passed) override;
virtual int construct_sql(const uint64_t tenant_id, ObSqlString& sql) override;
virtual int process();
virtual int process() override;
};
class ObAllTableV2SchemaSpliter : public ObTableSchemaSpliter {

4
src/rootserver/ob_upgrade_storage_format_version_executor.h
View File

@ -27,8 +27,8 @@ public:
explicit ObUpgradeStorageFormatVersionTask(ObUpgradeStorageFormatVersionExecutor& executor) : executor_(&executor)
{}
virtual ~ObUpgradeStorageFormatVersionTask() = default;
virtual int64_t get_deep_copy_size() const;
share::ObAsyncTask* deep_copy(char* buf, const int64_t buf_size) const;
virtual int64_t get_deep_copy_size() const override;
share::ObAsyncTask* deep_copy(char* buf, const int64_t buf_size) const override;
virtual int process() override;
private:

6
src/rootserver/restore/ob_restore_scheduler.h
View File

@ -61,8 +61,8 @@ public:
const common::ObAddr& self_addr);
virtual void run3() override;
void wakeup();
void stop();
virtual int blocking_run()
void stop() override;
virtual int blocking_run() override
{
BLOCKING_RUN_IMPLEMENT();
}
@ -73,7 +73,7 @@ public:
private:
int idle();
int check_stop() const;
int check_stop() const override;
int process_restore_job(const share::ObPhysicalRestoreJob& job);
int try_recycle_job(const share::ObPhysicalRestoreJob& job);

8
src/share/cache/ob_kv_storecache.h vendored
View File

@ -88,11 +88,11 @@ public:
int init(const uint64_t tenant_id, ObKVCache<Key, Value>& cache);
void reset();
void destroy();
virtual int put(const Key& key, const Value& value, bool overwrite = true);
virtual int put(const Key& key, const Value& value, bool overwrite = true) override;
virtual int put_and_fetch(
const Key& key, const Value& value, const Value*& pvalue, ObKVCacheHandle& handle, bool overwrite = true);
virtual int get(const Key& key, const Value*& pvalue, ObKVCacheHandle& handle);
virtual int erase(const Key& key);
const Key& key, const Value& value, const Value*& pvalue, ObKVCacheHandle& handle, bool overwrite = true) override;
virtual int get(const Key& key, const Value*& pvalue, ObKVCacheHandle& handle) override;
virtual int erase(const Key& key) override;
int64_t get_used() const
{

2
src/share/partition_table/ob_partition_table_operator.h
View File

@ -53,7 +53,7 @@ public:
virtual int prefetch(const uint64_t tenant_id, const uint64_t start_table_id, const int64_t set_partition_id,
common::ObIArray<ObPartitionInfo>& partition_infos, bool ignore_row_checksum,
const bool need_fetch_faillist = false);
const bool need_fetch_faillist = false) override;
virtual int prefetch(const uint64_t pt_table_id, const int64_t pt_partition_id, const uint64_t start_table_id,
const int64_t start_partition_id, common::ObIArray<ObPartitionInfo>& partition_infos,

10
src/share/stat/ob_opt_stat_manager.h
View File

@ -72,11 +72,11 @@ public:
{}
virtual ~ObRefreshStatTask()
{}
virtual int64_t hash() const
virtual int64_t hash() const override
{
return 0;
}
virtual bool operator==(const common::IObDedupTask& other) const
virtual bool operator==(const common::IObDedupTask& other) const override
{
UNUSED(other);
return false;
@ -85,12 +85,12 @@ public:
{
return sizeof(*this);
}
virtual common::IObDedupTask* deep_copy(char* buffer, const int64_t buf_size) const;
virtual int64_t get_abs_expired_time() const
virtual common::IObDedupTask* deep_copy(char* buffer, const int64_t buf_size) const override;
virtual int64_t get_abs_expired_time() const override
{
return 0;
}
virtual int process();
virtual int process() override;
int init(const obrpc::ObUpdateStatCacheArg& analyze_arg)
{
return analyze_arg_.assign(analyze_arg);

4
src/sql/engine/basic/ob_material.h
View File

@ -34,8 +34,8 @@ public:
ObMaterialInput() : bypass_(false)
{}
virtual ~ObMaterialInput() = default;
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op);
virtual ObPhyOperatorType get_phy_op_type() const;
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op) override;
virtual ObPhyOperatorType get_phy_op_type() const override;
virtual void reset() override
{
bypass_ = false;

14
src/sql/engine/dml/ob_multi_part_delete.h
View File

@ -26,7 +26,7 @@ public:
explicit ObMultiPartDelete(common::ObIAllocator& allocator);
virtual ~ObMultiPartDelete();
virtual int create_operator_input(ObExecContext& ctx) const
virtual int create_operator_input(ObExecContext& ctx) const override
{
UNUSED(ctx);
return common::OB_SUCCESS;
@ -35,7 +35,7 @@ public:
{
return subplan_has_foreign_key();
}
virtual bool is_multi_dml() const
virtual bool is_multi_dml() const override
{
return true;
}
@ -46,23 +46,23 @@ private:
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int inner_close(ObExecContext& ctx) const override;
/**
* @brief init operator context, will create a physical operator context (and a current row space)
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
int init_op_ctx(ObExecContext& ctx) const;
int init_op_ctx(ObExecContext& ctx) const override;
int shuffle_delete_row(ObExecContext& ctx, bool& got_row) const;
/**
* @brief called by get_next_row(), get a row from the child operator or row_store
* @param ctx[in], execute context
* @param row[out], ObSqlRow an obj array and row_size
*/
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const override;
};
} // namespace sql
} // namespace oceanbase

16
src/sql/engine/dml/ob_multi_part_insert.h
View File

@ -28,7 +28,7 @@ public:
explicit ObMultiPartInsert(common::ObIAllocator& alloc);
virtual ~ObMultiPartInsert();
virtual int create_operator_input(ObExecContext& ctx) const
virtual int create_operator_input(ObExecContext& ctx) const override
{
UNUSED(ctx);
return common::OB_SUCCESS;
@ -37,10 +37,10 @@ public:
{
return subplan_has_foreign_key();
}
void reset();
void reuse();
void reset() override;
void reuse() override;
int set_insert_row_exprs();
virtual bool is_multi_dml() const
virtual bool is_multi_dml() const override
{
return true;
}
@ -51,15 +51,15 @@ protected:
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
virtual int init_op_ctx(ObExecContext& ctx) const;
virtual int init_op_ctx(ObExecContext& ctx) const override;
/**
* @brief open operator, not including children operators.
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const;
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const override;
virtual int inner_close(ObExecContext& ctx) const override;
int shuffle_insert_row(ObExecContext& ctx, bool& got_row) const;
protected:

14
src/sql/engine/dml/ob_multi_part_update.h
View File

@ -27,7 +27,7 @@ public:
explicit ObMultiPartUpdate(common::ObIAllocator& allocator);
virtual ~ObMultiPartUpdate();
virtual int create_operator_input(ObExecContext& ctx) const
virtual int create_operator_input(ObExecContext& ctx) const override
{
UNUSED(ctx);
return common::OB_SUCCESS;
@ -36,7 +36,7 @@ public:
{
return subplan_has_foreign_key();
}
virtual bool is_multi_dml() const
virtual bool is_multi_dml() const override
{
return true;
}
@ -47,17 +47,17 @@ private:
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int inner_close(ObExecContext& ctx) const override;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const override;
/**
* @brief init operator context, will create a physical operator context (and a current row space)
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
int init_op_ctx(ObExecContext& ctx) const;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
int init_op_ctx(ObExecContext& ctx) const override;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
int shuffle_update_row(ObExecContext& ctx, bool& got_row) const;
int merge_implicit_cursor(
const common::ObNewRow& full_row, bool is_update, bool client_found_rows, ObPhysicalPlanCtx& plan_ctx) const;

10
src/sql/engine/dml/ob_multi_table_insert_up.h
View File

@ -34,7 +34,7 @@ public:
explicit ObMultiTableInsertUp(common::ObIAllocator& alloc);
virtual ~ObMultiTableInsertUp();
virtual int create_operator_input(ObExecContext& ctx) const
virtual int create_operator_input(ObExecContext& ctx) const override
{
UNUSED(ctx);
return common::OB_SUCCESS;
@ -49,7 +49,7 @@ public:
}
int shuffle_final_delete_row(ObExecContext& ctx, const common::ObNewRow& delete_row) const;
int shuffle_final_insert_row(ObExecContext& ctx, const common::ObNewRow& insert_row) const;
virtual bool is_multi_dml() const
virtual bool is_multi_dml() const override
{
return true;
}
@ -60,14 +60,14 @@ protected:
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
virtual int init_op_ctx(ObExecContext& ctx) const;
virtual int init_op_ctx(ObExecContext& ctx) const override;
/**
* @brief open operator, not including children operators.
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int inner_close(ObExecContext& ctx) const override;
int load_insert_up_row(ObExecContext& ctx, common::ObRowStore& row_store) const;
int shuffle_insert_up_row(ObExecContext& ctx, bool& got_row) const;
int shuffle_insert_row(ObExecContext& ctx, common::ObPartMgr& part_mgr, ObMultiTableInsertUpCtx& replace_ctx,

10
src/sql/engine/dml/ob_multi_table_replace.h
View File

@ -34,7 +34,7 @@ public:
explicit ObMultiTableReplace(common::ObIAllocator& alloc);
virtual ~ObMultiTableReplace();
virtual int create_operator_input(ObExecContext& ctx) const
virtual int create_operator_input(ObExecContext& ctx) const override
{
UNUSED(ctx);
return common::OB_SUCCESS;
@ -49,7 +49,7 @@ public:
}
int shuffle_final_delete_row(ObExecContext& ctx, const common::ObNewRow& delete_row) const;
int shuffle_final_insert_row(ObExecContext& ctx, const common::ObNewRow& insert_row) const;
virtual bool is_multi_dml() const
virtual bool is_multi_dml() const override
{
return true;
}
@ -60,14 +60,14 @@ protected:
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
virtual int init_op_ctx(ObExecContext& ctx) const;
virtual int init_op_ctx(ObExecContext& ctx) const override;
/**
* @brief open operator, not including children operators.
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int inner_close(ObExecContext& ctx) const override;
int load_replace_row(ObExecContext& ctx, common::ObRowStore& row_store) const;
int shuffle_replace_row(ObExecContext& ctx, bool& got_row) const;

14
src/sql/engine/dml/ob_table_insert_all.h
View File

@ -69,7 +69,7 @@ public:
explicit ObMultiTableInsert(common::ObIAllocator& alloc);
virtual ~ObMultiTableInsert();
virtual int create_operator_input(ObExecContext& ctx) const
virtual int create_operator_input(ObExecContext& ctx) const override
{
UNUSED(ctx);
return common::OB_SUCCESS;
@ -78,7 +78,7 @@ public:
{
return subplan_has_foreign_key();
}
void reset();
void reset() override;
int check_match_conditions(ObExprCtx& expr_ctx, const ObNewRow& row, bool have_insert_row,
const InsertTableInfo* table_info, int64_t& pre_when_conds_idx, bool& continue_insert, bool& is_match) const;
bool is_multi_insert_first() const
@ -103,7 +103,7 @@ public:
{
return idx < multi_table_insert_infos_.count() ? multi_table_insert_infos_.at(idx) : NULL;
}
virtual bool is_multi_dml() const
virtual bool is_multi_dml() const override
{
return true;
}
@ -114,15 +114,15 @@ protected:
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
virtual int init_op_ctx(ObExecContext& ctx) const;
virtual int init_op_ctx(ObExecContext& ctx) const override;
/**
* @brief open operator, not including children operators.
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const;
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int get_next_row(ObExecContext& ctx, const ObNewRow*& row) const override;
virtual int inner_close(ObExecContext& ctx) const override;
int shuffle_insert_row(ObExecContext& ctx, bool& got_row) const;
int process_row(ObExecContext& ctx, ObMultiTableInsertCtx& insert_ctx, const ObNewRow*& insert_row) const;
int prepare_insert_row(const ObNewRow* input_row, const DMLSubPlan& insert_dml_sub, ObNewRow& new_row) const;

22
src/sql/engine/dml/ob_table_modify.h
View File

@ -354,7 +354,7 @@ public:
is_single_part_ = false;
part_infos_.reset();
}
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op);
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op) override;
inline int64_t get_location_idx() const
{
return location_idx_;
@ -363,7 +363,7 @@ public:
{
location_idx_ = location_idx;
}
virtual bool need_serialized() const
virtual bool need_serialized() const override
{
return !is_single_part_;
}
@ -371,7 +371,7 @@ public:
* @brief set allocator which is used for deserialize, but not all objects will use allocator
* while deserializing, so you can override it if you need.
*/
virtual void set_deserialize_allocator(common::ObIAllocator* allocator)
virtual void set_deserialize_allocator(common::ObIAllocator* allocator) override
{
part_infos_.set_allocator(allocator);
}
@ -533,8 +533,8 @@ public:
explicit ObTableModify(common::ObIAllocator& alloc);
~ObTableModify();
void reset();
void reuse();
void reset() override;
void reuse() override;
/**
* @brief the table id specify which table will be modified data
*/
@ -549,7 +549,7 @@ public:
// void set_child_table_id(uint64_t table_id) { child_table_id_ = table_id; }
// void set_parent_table_id(uint64_t table_id) { parent_table_id_ = table_id; }
int add_column_info(const ColumnContent& column);
virtual int create_operator_input(ObExecContext& ctx) const;
virtual int create_operator_input(ObExecContext& ctx) const override;
/**
* @brief table_modify must tell storage every cell's column id in the row
* @param column_id[in], the order of column_id must correspond with the index of column in the row
@ -630,11 +630,11 @@ public:
{
return index_tid_;
}
virtual bool is_dml_operator() const
virtual bool is_dml_operator() const override
{
return true;
}
virtual bool is_dml_without_output() const
virtual bool is_dml_without_output() const override
{
return !is_returning();
}
@ -648,7 +648,7 @@ public:
{
return from_multi_table_dml_;
}
virtual OperatorOpenOrder get_operator_open_order(ObExecContext& ctx) const;
virtual OperatorOpenOrder get_operator_open_order(ObExecContext& ctx) const override;
static common::ObString get_duplicated_rowkey_buffer(const common::ObIArray<uint64_t>& rowkey_ids,
const common::ObNewRow& row, const common::ObTimeZoneInfo* tz_info = NULL);
static int init_dml_param(ObExecContext& ctx, const uint64_t table_id, const ObPhyOperator& phy_op,
@ -743,12 +743,12 @@ protected:
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
/**
* @brief close operator, not including children operators.
* Every op should implement this method.
*/
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const override;
int calculate_virtual_column(common::ObExprCtx& expr_ctx, common::ObNewRow& calc_row, int64_t row_num) const;
int calc_returning_row(ObExprCtx& expr_ctx, const ObNewRow& cur_row, ObNewRow& return_row) const;

16
src/sql/engine/dml/ob_table_update.h
View File

@ -113,10 +113,10 @@ public:
explicit ObTableUpdate(common::ObIAllocator& alloc);
virtual ~ObTableUpdate();
void reset();
void reuse();
void reset() override;
void reuse() override;
virtual int rescan(ObExecContext& ctx) const override;
int get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
int get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
virtual int switch_iterator(ObExecContext& ctx) const override;
int init_updated_column_count(common::ObIAllocator& allocator, int64_t count)
{
@ -161,25 +161,25 @@ protected:
* @param ctx[in], execute context
* @param row[out], ObSqlRow an obj array and row_size
*/
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
/**
* @brief open operator, not including children operators.
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
/**
* @brief close operator, not including children operators.
* Every op should implement this method.
*/
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const override;
/**
* @brief init operator context, will create a physical operator context (and a current row space)
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
int init_op_ctx(ObExecContext& ctx) const;
virtual int64_t to_string_kv(char* buf, const int64_t buf_len) const;
int init_op_ctx(ObExecContext& ctx) const override;
virtual int64_t to_string_kv(char* buf, const int64_t buf_len) const override;
inline int update_rows(ObExecContext& ctx, int64_t& affected_rows) const;
int build_lock_row(ObTableUpdateCtx& update_ctx, const common::ObNewRow& old_row) const;
int do_table_update(ObExecContext& ctx) const;

2
src/sql/engine/expr/ob_expr_operator.h
View File

@ -1153,7 +1153,7 @@ public:
virtual ~ObSubQueryRelationalExpr()
{}
virtual int assign(const ObExprOperator& other);
virtual int assign(const ObExprOperator& other) override;
void set_subquery_key(ObSubQueryKey key)
{

2
src/sql/engine/pdml/ob_px_multi_part_modify.h
View File

@ -79,7 +79,7 @@ public:
virtual void reset() override
{ /*@TODO fix reset member*/
}
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op);
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op) override;
virtual void set_task_id(int64_t task_id)
{
task_id_ = task_id;

32
src/sql/engine/px/ob_px_row_store.h
View File

@ -43,16 +43,16 @@ public:
ObPxNewRowIterator();
virtual ~ObPxNewRowIterator();
int get_next_row(common::ObNewRow& row);
int get_next_row(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx)
int get_next_row(common::ObNewRow& row) override;
int get_next_row(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx) override
{
UNUSED(exprs);
UNUSED(eval_ctx);
return common::OB_ERR_UNEXPECTED;
}
void reset();
void reset() override;
bool is_inited()
bool is_inited() override
{
return is_inited_;
}
@ -60,7 +60,7 @@ public:
{
is_inited_ = true;
}
bool has_next()
bool has_next() override
{
return rows_ > 0 && row_store_it_.has_next();
}
@ -69,7 +69,7 @@ public:
return is_eof_;
}
bool is_iter_end()
bool is_iter_end() override
{
return is_iter_end_;
}
@ -79,8 +79,8 @@ public:
return row_store_.get_row_cnt();
}
void set_iterator_end();
int load_buffer(const dtl::ObDtlLinkedBuffer& buffer);
void set_iterator_end() override;
int load_buffer(const dtl::ObDtlLinkedBuffer& buffer) override;
void set_rows(int64_t rows)
{
rows_ = rows;
@ -105,15 +105,15 @@ public:
ObPxDatumRowIterator();
virtual ~ObPxDatumRowIterator();
int get_next_row(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx);
int get_next_row(common::ObNewRow& row)
int get_next_row(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx) override;
int get_next_row(common::ObNewRow& row) override
{
UNUSED(row);
return common::OB_ERR_UNEXPECTED;
}
void reset();
void reset() override;
bool is_inited()
bool is_inited() override
{
return is_inited_;
}
@ -121,7 +121,7 @@ public:
{
is_inited_ = true;
}
bool has_next()
bool has_next() override
{
return rows_ > 0 && datum_store_it_.has_next();
}
@ -130,7 +130,7 @@ public:
return is_eof_;
}
bool is_iter_end()
bool is_iter_end() override
{
return is_iter_end_;
}
@ -140,8 +140,8 @@ public:
return datum_store_.get_row_cnt();
}
void set_iterator_end();
int load_buffer(const dtl::ObDtlLinkedBuffer& buffer);
void set_iterator_end() override;
int load_buffer(const dtl::ObDtlLinkedBuffer& buffer) override;
void set_rows(int64_t rows)
{
rows_ = rows;

14
src/sql/engine/sort/ob_in_memory_topn_sort.h
View File

@ -29,15 +29,15 @@ class ObInMemoryTopnSort : public ObBaseSort {
public:
ObInMemoryTopnSort();
virtual ~ObInMemoryTopnSort();
virtual void reset();
virtual void reuse();
virtual int add_row(const common::ObNewRow& row, bool& need_sort);
virtual int sort_rows();
virtual int get_next_row(common::ObNewRow& row);
virtual void reset() override;
virtual void reuse() override;
virtual int add_row(const common::ObNewRow& row, bool& need_sort) override;
virtual int sort_rows() override;
virtual int get_next_row(common::ObNewRow& row) override;
virtual int64_t get_row_count() const override;
virtual int64_t get_used_mem_size() const override;
virtual int get_next_compact_row(common::ObString& compact_row);
virtual int set_sort_columns(const common::ObIArray<ObSortColumn>& sort_columns, const int64_t preifx_pos);
virtual int get_next_compact_row(common::ObString& compact_row) override;
virtual int set_sort_columns(const common::ObIArray<ObSortColumn>& sort_columns, const int64_t preifx_pos) override;
inline void set_fetch_with_ties(bool is_fetch_with_ties)
{
is_fetch_with_ties_ = is_fetch_with_ties;

16
src/sql/engine/sort/ob_local_merge_sort.h
View File

@ -49,16 +49,16 @@ public:
ObLocalMergeSort();
virtual ~ObLocalMergeSort();
virtual void reset();
virtual void reuse();
virtual int add_row(const common::ObNewRow& row, bool& need_sort);
virtual int sort_rows();
virtual int get_next_row(common::ObNewRow& row);
virtual void reset() override;
virtual void reuse() override;
virtual int add_row(const common::ObNewRow& row, bool& need_sort) override;
virtual int sort_rows() override;
virtual int get_next_row(common::ObNewRow& row) override;
virtual int64_t get_used_mem_size() const override;
virtual int inner_dump(ObIMergeSort& merge_sort, bool dump_last);
virtual int dump(ObIMergeSort& merge_sort);
virtual int final_dump(ObIMergeSort& merge_sort);
virtual int set_sort_columns(const common::ObIArray<ObSortColumn>& sort_columns, const int64_t preifx_pos);
virtual int dump(ObIMergeSort& merge_sort) override;
virtual int final_dump(ObIMergeSort& merge_sort) override;
virtual int set_sort_columns(const common::ObIArray<ObSortColumn>& sort_columns, const int64_t preifx_pos) override;
virtual void set_cur_input(int64_t nth_input)
{
cur_input_ = nth_input;

18
src/sql/engine/sort/ob_specific_columns_sort.h
View File

@ -26,14 +26,14 @@ public:
ObSpecificColumnsSort(const char* label, uint64_t malloc_block_size, uint64_t tenant_id,
oceanbase::common::ObCtxIds::ObCtxIdEnum ctx_id);
virtual ~ObSpecificColumnsSort(){};
virtual void reset();
virtual void reuse();
virtual void rescan();
virtual int set_sort_columns(const common::ObIArray<ObSortColumn>& sort_columns, const int64_t prefix_pos);
virtual int add_row(const common::ObNewRow& row, bool& need_sort);
virtual void reset() override;
virtual void reuse() override;
virtual void rescan() override;
virtual int set_sort_columns(const common::ObIArray<ObSortColumn>& sort_columns, const int64_t prefix_pos) override;
virtual int add_row(const common::ObNewRow& row, bool& need_sort) override;
int add_row_without_copy(common::ObNewRow* row);
virtual int sort_rows();
virtual int get_next_row(common::ObNewRow& row);
virtual int sort_rows() override;
virtual int get_next_row(common::ObNewRow& row) override;
int get_sort_result_array(common::ObArray<const common::ObNewRow*>& sort_result);
virtual int64_t get_row_count() const override
{
@ -43,12 +43,12 @@ public:
{
return row_alloc_.used();
}
virtual int init_tenant_id(uint64_t tenant_id)
virtual int init_tenant_id(uint64_t tenant_id) override
{
row_alloc_.set_tenant_id(tenant_id);
return common::OB_SUCCESS;
}
virtual int get_next_compact_row(common::ObString& compact_row)
virtual int get_next_compact_row(common::ObString& compact_row) override
{
UNUSED(compact_row);
return common::OB_SUCCESS;

22
src/sql/engine/table/ob_table_scan.h
View File

@ -54,14 +54,14 @@ public:
ObTableScanInput();
virtual ~ObTableScanInput();
virtual void reset() override;
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op);
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op) override;
int64_t get_location_idx() const;
inline void set_location_idx(int64_t location_idx)
{
location_idx_ = location_idx;
}
virtual ObPhyOperatorType get_phy_op_type() const;
virtual void set_deserialize_allocator(common::ObIAllocator* allocator);
virtual ObPhyOperatorType get_phy_op_type() const override;
virtual void set_deserialize_allocator(common::ObIAllocator* allocator) override;
int reassign_ranges(ObIArray<ObNewRange>& ranges);
int translate_pid_to_ldx(ObExecContext& ctx, int64_t partition_id, int64_t table_location_key, int64_t ref_table_id,
@ -193,15 +193,15 @@ public:
public:
explicit ObTableScan(common::ObIAllocator& allocator);
virtual ~ObTableScan();
virtual void reset();
virtual void reuse();
virtual void reset() override;
virtual void reuse() override;
// renew the TSC by a new granule task info and do table scan
int reassign_task_and_do_table_scan(ObExecContext& ctx, ObGranuleTaskInfo& info) const;
// get task from exection ctx
int get_gi_task_and_restart(ObExecContext& ctx) const;
// virtual int get_next_row(ObExecContext &ctx, const common::ObNewRow *&row) const;
virtual int rescan(ObExecContext& ctx) const;
virtual int create_operator_input(ObExecContext& ctx) const;
virtual int rescan(ObExecContext& ctx) const override;
virtual int create_operator_input(ObExecContext& ctx) const override;
DECLARE_VIRTUAL_TO_STRING;
@ -574,20 +574,20 @@ protected:
* @param ctx[in], execute context
* @return if success, return OB_SUCCESS, otherwise, return errno
*/
virtual int init_op_ctx(ObExecContext& ctx) const;
virtual int init_op_ctx(ObExecContext& ctx) const override;
virtual bool need_filter_row() const override;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
/**
* @brief open operator, not including children operators.
* called by open.
* Every op should implement this method.
*/
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_open(ObExecContext& ctx) const override;
/**
* @brief close operator, not including children operators.
* Every op should implement this method.
*/
virtual int inner_close(ObExecContext& ctx) const;
virtual int inner_close(ObExecContext& ctx) const override;
// helper
int calc_expr_int_value(
common::ObExprCtx& expr_ctx, const ObSqlExpression& expr, int64_t& retval, bool& is_null_value) const;

4
src/sql/executor/ob_distributed_transmit.h
View File

@ -38,8 +38,8 @@ public:
force_save_interm_result_ = false;
slice_events_ = NULL;
}
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op);
inline virtual ObPhyOperatorType get_phy_op_type() const
virtual int init(ObExecContext& ctx, ObTaskInfo& task_info, const ObPhyOperator& op) override;
inline virtual ObPhyOperatorType get_phy_op_type() const override
{
return PHY_DISTRIBUTED_TRANSMIT;
}

10
src/sql/executor/ob_transmit.h
View File

@ -84,8 +84,8 @@ public:
explicit ObTransmit(common::ObIAllocator& alloc);
virtual ~ObTransmit();
// virtual int close(ObExecContext &ctx) const;
void reset();
void reuse();
void reset() override;
void reuse() override;
inline void set_interm_result_manager(ObIntermResultManager* result_mgr);
inline void set_split_task_count(int64_t count);
inline int64_t get_split_task_count() const;
@ -106,7 +106,7 @@ public:
{
return job_conf_;
}
int add_compute(ObColumnExpression* expr);
int add_compute(ObColumnExpression* expr) override;
int add_filter(ObSqlExpression* expr);
int init_repart_columns(int64_t repart_count, int64_t repart_sub_count);
@ -208,8 +208,8 @@ public:
}
protected:
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
virtual int inner_open(ObExecContext& ctx) const;
virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
virtual int inner_open(ObExecContext& ctx) const override;
virtual int64_t to_string_kv(char* buf, const int64_t buf_len) const override;
protected:

4
src/sql/ob_sql_partition_location_cache.h
View File

@ -35,7 +35,7 @@ public:
share::schema::ObSchemaGetterGuard* guard_schema);
bool is_inited() const;
virtual ObIPartitionLocationCache::PartitionLocationCacheType get_type() const
virtual ObIPartitionLocationCache::PartitionLocationCacheType get_type() const override
{
return ObIPartitionLocationCache::PART_LOC_CACHE_TYPE_SQL;
}
@ -80,7 +80,7 @@ public:
const common::ObPartitionKey& partition, const int64_t expire_renew_time, bool& is_limited) override;
// link table.
virtual int get_link_table_location(const uint64_t table_id, share::ObPartitionLocation& location);
virtual int get_link_table_location(const uint64_t table_id, share::ObPartitionLocation& location) override;
ObSqlPartitionLocationCache::LocationDistributedMode get_location_distributed_mode(const uint64_t table_id) const;

6
src/sql/optimizer/ob_join_order.h
View File

@ -396,7 +396,7 @@ public:
return est_cost_info_;
}
const ObShardingInfo* get_sharding_info() const;
virtual void get_name_internal(char* buf, const int64_t buf_len, int64_t& pos) const
virtual void get_name_internal(char* buf, const int64_t buf_len, int64_t& pos) const override
{
BUF_PRINTF("@");
BUF_PRINTF("%lu", table_id_);
@ -483,7 +483,7 @@ public:
int cost_nest_loop_join(double& op_cost, double& cost);
int cost_merge_join(double& op_cost, double& cost);
int cost_hash_join(double& op_cost, double& cost);
virtual void get_name_internal(char* buf, const int64_t buf_len, int64_t& pos) const
virtual void get_name_internal(char* buf, const int64_t buf_len, int64_t& pos) const override
{
BUF_PRINTF("<");
if (NULL != left_path_) {
@ -542,7 +542,7 @@ public:
virtual ~SubQueryPath()
{}
virtual int estimate_cost() override;
virtual void get_name_internal(char* buf, const int64_t buf_len, int64_t& pos) const
virtual void get_name_internal(char* buf, const int64_t buf_len, int64_t& pos) const override
{
BUF_PRINTF("@sub_");
BUF_PRINTF("%lu", subquery_id_);

4
src/sql/optimizer/ob_log_append.h
View File

@ -35,13 +35,13 @@ public:
{
type_ = type;
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override
{
UNUSED(ctx);
return common::OB_NOT_SUPPORTED;
}
virtual bool is_consume_child_1by1() const
virtual bool is_consume_child_1by1() const override
{
return true;
}

4
src/sql/optimizer/ob_log_conflict_row_fetcher.h
View File

@ -51,7 +51,7 @@ public:
{
return conflict_exprs_;
}
uint64_t hash(uint64_t seed) const;
uint64_t hash(uint64_t seed) const override;
void set_table_id(uint64_t table_id)
{
table_id_ = table_id;
@ -80,7 +80,7 @@ public:
TO_STRING_KV(K_(table_id), K_(index_tid), K_(only_data_table), K_(conflict_exprs), K_(access_exprs));
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
private:
uint64_t table_id_;

10
src/sql/optimizer/ob_log_count.h
View File

@ -24,7 +24,7 @@ public:
{}
virtual ~ObLogCount()
{}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int generate_link_sql_pre(GenLinkStmtContext& link_ctx) override;
inline ObRawExpr* get_rownum_limit_expr() const
@ -37,11 +37,11 @@ public:
}
int set_limit_size();
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual uint64_t hash(uint64_t seed) const;
int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual uint64_t hash(uint64_t seed) const override;
int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
private:
ObRawExpr* rownum_limit_expr_;

10
src/sql/optimizer/ob_log_del_upd.h
View File

@ -82,14 +82,14 @@ public:
{
check_constraint_exprs_ = check_constraint_exprs;
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual uint64_t get_hash(uint64_t seed) const
{
return seed;
}
virtual uint64_t hash(uint64_t seed) const;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual uint64_t hash(uint64_t seed) const override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int reordering_project_columns() override;
void set_ignore(bool is_ignore)
{
@ -195,7 +195,7 @@ public:
{
table_columns_ = table_columns;
}
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
ObTablePartitionInfo& get_table_partition_info()
{
@ -261,7 +261,7 @@ private:
int do_reordering_project_columns(ObLogicalOperator& child);
protected:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int add_exprs_to_ctx_for_pdml(
ObAllocExprContext& ctx, const ObIArray<ObRawExpr*>& input_exprs, uint64_t producer_id);

6
src/sql/optimizer/ob_log_delete.h
View File

@ -32,14 +32,14 @@ public:
*/
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int est_cost();
virtual int est_cost() override;
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
out = NULL;
return common::OB_SUCCESS;
}
virtual const char* get_name() const;
virtual const char* get_name() const override;
private:
DISALLOW_COPY_AND_ASSIGN(ObLogDelete);

12
src/sql/optimizer/ob_log_distinct.h
View File

@ -24,13 +24,13 @@ public:
virtual ~ObLogDistinct()
{}
const char* get_name() const;
const char* get_name() const override;
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
int push_down_distinct(
AllocExchContext* ctx, common::ObIArray<OrderItem>& sort_keys, ObLogicalOperator*& exchange_point);
int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
// this interface can be used for adding distinct expr
inline ObIArray<ObRawExpr*>& get_distinct_exprs()
{
@ -49,8 +49,8 @@ public:
return append(distinct_exprs_, exprs);
}
virtual int inner_replace_generated_agg_expr(
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs);
uint64_t hash(uint64_t seed) const;
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs) override;
uint64_t hash(uint64_t seed) const override;
inline void set_hash_type()
{
@ -78,7 +78,7 @@ public:
}
virtual int est_cost() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int transmit_op_ordering();
virtual int transmit_op_ordering() override;
virtual bool is_block_op() const override
{
return false;

20
src/sql/optimizer/ob_log_exchange.h
View File

@ -38,7 +38,7 @@ public:
virtual ~ObLogExchange()
{}
virtual int est_cost() override;
virtual const char* get_name() const;
virtual const char* get_name() const override;
int set_sort_keys(const common::ObIArray<OrderItem>& order_keys);
const common::ObIArray<OrderItem>& get_sort_keys() const
{
@ -132,18 +132,18 @@ public:
{
return is_merge_sort_;
}
inline bool is_block_op() const
inline bool is_block_op() const override
{
return is_local_order_;
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int32_t get_explain_name_length() const;
virtual int get_explain_name_internal(char* buf, const int64_t buf_len, int64_t& pos);
virtual int32_t get_explain_name_length() const override;
virtual int get_explain_name_internal(char* buf, const int64_t buf_len, int64_t& pos) override;
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
int check_output_dep_specific(ObRawExprCheckDep& checker);
int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int set_exchange_info(ObExchangeInfo& exch_info);
virtual int transmit_op_ordering();
virtual int transmit_op_ordering() override;
const common::ObIArray<ObRawExpr*>& get_repart_keys() const
{
return exch_info_.repartition_keys_;
@ -212,7 +212,7 @@ public:
virtual int px_pipe_blocking_post(ObPxPipeBlockingCtx& ctx) override;
virtual int allocate_granule_post(AllocGIContext& ctx) override;
virtual int allocate_granule_pre(AllocGIContext& ctx) override;
uint64_t hash(uint64_t seed) const;
uint64_t hash(uint64_t seed) const override;
bool is_local_order() const
{
return is_local_order_;
@ -222,7 +222,7 @@ public:
is_local_order_ = local_order;
}
virtual int compute_op_ordering() override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
SlaveMappingType get_slave_mapping_type()
{
return exch_info_.get_slave_mapping_type();
@ -234,7 +234,7 @@ public:
int update_sharding_conds(AllocExchContext& ctx);
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int print_plan_head_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int inner_replace_generated_agg_expr(

8
src/sql/optimizer/ob_log_expr_values.h
View File

@ -21,7 +21,7 @@ public:
ObLogExprValues(ObLogPlan& plan) : ObLogicalOperator(plan), need_columnlized_(false)
{}
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
return clone(out);
}
@ -56,13 +56,13 @@ public:
virtual int compute_table_set() override;
virtual int compute_fd_item_set() override;
virtual int compute_one_row_info() override;
virtual int allocate_dummy_output();
uint64_t hash(uint64_t seed) const;
virtual int allocate_dummy_output() override;
uint64_t hash(uint64_t seed) const override;
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
private:
bool need_columnlized_;

8
src/sql/optimizer/ob_log_function_table.h
View File

@ -25,7 +25,7 @@ public:
{}
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
void add_values_expr(ObRawExpr* expr)
{
value_expr_ = expr;
@ -43,7 +43,7 @@ public:
virtual int compute_equal_set() override;
virtual int compute_fd_item_set() override;
virtual int compute_table_set() override;
uint64_t hash(uint64_t seed) const;
uint64_t hash(uint64_t seed) const override;
int generate_access_exprs(ObIArray<ObRawExpr*>& access_exprs) const;
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
@ -56,10 +56,10 @@ public:
{
return table_id_;
}
int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
private:
uint64_t table_id_;

2
src/sql/optimizer/ob_log_granule_iterator.h
View File

@ -33,7 +33,7 @@ public:
virtual ~ObLogGranuleIterator()
{}
const char* get_name() const;
const char* get_name() const override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;

20
src/sql/optimizer/ob_log_group_by.h
View File

@ -35,8 +35,8 @@ public:
{}
// const char* get_name() const;
virtual int32_t get_explain_name_length() const;
virtual int get_explain_name_internal(char* buf, const int64_t buf_len, int64_t& pos);
virtual int32_t get_explain_name_length() const override;
virtual int get_explain_name_internal(char* buf, const int64_t buf_len, int64_t& pos) override;
// Get the 'group-by' expressions
inline common::ObIArray<ObRawExpr*>& get_group_by_exprs()
{
@ -56,7 +56,7 @@ public:
{
return rollup_exprs_.count() > 0;
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
inline void set_hash_type()
{
algo_ = HASH_AGGREGATE;
@ -83,7 +83,7 @@ public:
// @brief SET the ROLLUP COLUMNS
int set_rollup_exprs(const common::ObIArray<ObRawExpr*>& rollup_exprs);
int set_aggr_exprs(const common::ObIArray<ObAggFunRawExpr*>& aggr_exprs);
ObSelectLogPlan* get_plan()
ObSelectLogPlan* get_plan() override
{
return static_cast<ObSelectLogPlan*>(my_plan_);
}
@ -97,11 +97,11 @@ public:
common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& group_push_down_replaced_exprs);
int should_push_down_group_by(AllocExchContext& ctx, ObIArray<ObRawExpr*>& distinct_exprs, bool& should_push_groupby,
bool& should_push_distinct);
virtual uint64_t hash(uint64_t seed) const;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual uint64_t hash(uint64_t seed) const override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int est_cost() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int transmit_op_ordering();
virtual int transmit_op_ordering() override;
virtual bool is_block_op() const override
{
return MERGE_AGGREGATE != get_algo();
@ -146,7 +146,7 @@ private:
*/
int pull_up_aggr_exprs_analyze(
common::ObIArray<ObRawExpr*>& aggr_exprs, common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& ctx_record_arr);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
int get_child_groupby_algorithm(const bool is_distinct, const bool can_push_down_distinct, const bool need_sort,
const bool child_need_sort, AggregateAlgo& aggr_algo);
@ -157,8 +157,8 @@ private:
common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& ctx_record_arr,
common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& push_down_arr);
virtual int inner_replace_generated_agg_expr(
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs);
virtual int print_outline(planText& plan);
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs) override;
virtual int print_outline(planText& plan) override;
int is_need_print_agg_type(planText& plan_text, const ObStmtHint& stmt_hint, bool& is_need);
int alloc_topk_if_needed();
int allocate_topk_if_needed(ObLogicalOperator* exchange_point, const ObLogGroupBy* child_group_by,

12
src/sql/optimizer/ob_log_insert.h
View File

@ -133,7 +133,7 @@ public:
virtual ~ObLogInsert()
{}
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
out = NULL;
return common::OB_SUCCESS;
@ -149,7 +149,7 @@ public:
virtual int inner_replace_generated_agg_expr(
const ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs) override;
const char* get_name() const;
const char* get_name() const override;
int calc_cost();
inline const common::ObIArray<ObRawExpr*>* get_column_convert_exprs() const
@ -233,9 +233,9 @@ public:
/**
* Get the hash value of the INSERT operator
*/
virtual uint64_t hash(uint64_t seed) const;
virtual uint64_t hash(uint64_t seed) const override;
int generate_sharding_info(ObShardingInfo& target_sharding_info);
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
int calculate_table_location();
int get_join_keys(const AllocExchContext& ctx, ObIArray<ObRawExpr*>& target_keys, ObIArray<ObRawExpr*>& source_keys);
@ -262,11 +262,11 @@ private:
protected:
int add_exprs_without_column_conv(
const common::ObIArray<ObRawExpr*>& src_exprs, common::ObIArray<ObRawExpr*>& dst_exprs);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int need_multi_table_dml(AllocExchContext& ctx, ObShardingInfo& sharding_info, bool& is_needed) override;
bool is_table_update_part_key() const;
bool is_table_insert_sequence_part_key() const;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
protected:
bool is_replace_;

8
src/sql/optimizer/ob_log_insert_all.h
View File

@ -37,12 +37,12 @@ public:
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int extract_value_exprs();
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int extract_value_exprs() override;
virtual int inner_replace_generated_agg_expr(
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*>>& to_replace_exprs) override;
const char* get_name() const;
const char* get_name() const override;
const common::ObIArray<RawExprArray>& get_multi_value_exprs() const
{
return multi_value_exprs_;
@ -103,7 +103,7 @@ public:
int remove_const_expr(const common::ObIArray<ObRawExpr*>& old_exprs, common::ObIArray<ObRawExpr*>& new_exprs) const;
protected:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int need_multi_table_dml(AllocExchContext& ctx, ObShardingInfo& sharding_info, bool& is_needed) override;
int is_insert_table_id(uint64_t table_id, bool& is_true) const;

26
src/sql/optimizer/ob_log_join.h
View File

@ -174,7 +174,7 @@ public:
{
return get_child(second_child);
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
int gen_filters();
int gen_output_columns();
/**
@ -184,7 +184,7 @@ public:
int update_weak_part_exprs(AllocExchContext* ctx);
virtual int allocate_expr_post(ObAllocExprContext& ctx);
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
//@brief Set all the join predicates
int set_join_conditions(const common::ObIArray<ObRawExpr*>& conditions)
{
@ -225,7 +225,7 @@ public:
return right_expected_ordering_;
}
virtual int inner_replace_generated_agg_expr(
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs);
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs) override;
const common::ObIArray<ObOrderDirection>& get_merge_directions() const
{
return merge_directions_;
@ -238,15 +238,15 @@ public:
/**
* Get the operator's hash value
*/
virtual uint64_t hash(uint64_t seed) const;
virtual uint64_t hash(uint64_t seed) const override;
// const char* get_name() const;
virtual int32_t get_explain_name_length() const;
virtual int get_explain_name_internal(char* buf, const int64_t buf_len, int64_t& pos);
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int32_t get_explain_name_length() const override;
virtual int get_explain_name_internal(char* buf, const int64_t buf_len, int64_t& pos) override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int re_calc_cost();
virtual int transmit_op_ordering();
virtual int re_calc_cost() override;
virtual int transmit_op_ordering() override;
/*
* IN right_child_sharding_info the join's right child sharding info
* IN right_keys the right join equal condition
@ -255,7 +255,7 @@ public:
int bloom_filter_partition_type(
const ObShardingInfo& right_child_sharding_info, ObIArray<ObRawExpr*>& right_keys, PartitionFilterType& type);
virtual bool is_block_input(const int64_t child_idx) const override;
virtual bool is_consume_child_1by1() const
virtual bool is_consume_child_1by1() const override
{
return HASH_JOIN == join_algo_;
}
@ -271,7 +271,7 @@ public:
return (NESTED_LOOP_JOIN == join_algo_) && nl_params_.empty();
}
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
virtual int compute_table_set() override;
bool is_enable_gi_partition_pruning() const
@ -305,8 +305,8 @@ private:
ObIArray<ObExprCalcType>& calc_types);
int make_sort_keys(common::ObIArray<ObRawExpr*>& sort_expr, common::ObIArray<OrderItem>& directions);
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_outline(planText& plan);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int print_outline(planText& plan) override;
int print_material_nl(planText& plan_text, JoinTreeType join_tree_type, bool is_need_print);
int print_use_join(planText& plan_text, JoinTreeType join_tree_type, bool is_need_print);
int print_pq_distribute(planText& plan_text, JoinTreeType join_tree_type, bool is_need_print);

12
src/sql/optimizer/ob_log_limit.h
View File

@ -90,15 +90,15 @@ public:
virtual int est_cost() override;
virtual int allocate_granule_pre(AllocGIContext &ctx);
virtual int allocate_granule_post(AllocGIContext &ctx);
virtual int allocate_exchange_post(AllocExchContext* ctx);
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int transmit_op_ordering() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual uint64_t hash(uint64_t seed) const;
virtual int copy_without_child(ObLogicalOperator*& out);
int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual uint64_t hash(uint64_t seed) const override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
void set_fetch_with_ties(bool is_fetch_with_ties)
{
is_fetch_with_ties_ = is_fetch_with_ties;

4
src/sql/optimizer/ob_log_link.h
View File

@ -25,8 +25,8 @@ public:
ObLogLink(ObLogPlan& plan);
virtual ~ObLogLink()
{}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int generate_link_sql_pre(GenLinkStmtContext& link_ctx) override;

2
src/sql/optimizer/ob_log_material.h
View File

@ -23,7 +23,7 @@ public:
{}
virtual ~ObLogMaterial()
{}
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
return clone(out);
}

8
src/sql/optimizer/ob_log_merge.h
View File

@ -81,16 +81,16 @@ public:
}
int add_delete_exprs_to_ctx(ObAllocExprContext& ctx);
int add_all_table_assignments_to_ctx(ObAllocExprContext& ctx);
virtual uint64_t hash(uint64_t seed) const;
const char* get_name() const;
virtual uint64_t hash(uint64_t seed) const override;
const char* get_name() const override;
int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
int add_merge_exprs_to_ctx(ObAllocExprContext& ctx, const ObIArray<ObRawExpr*>& exprs);
int classify_merge_subquery_expr(const ObIArray<ObRawExpr*>& exprs, ObIArray<ObRawExpr*>& subquery_exprs,
ObIArray<ObRawExpr*>& non_subquery_exprs);
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
int add_all_source_table_columns_to_ctx(ObAllocExprContext& ctx);
DISALLOW_COPY_AND_ASSIGN(ObLogMerge);

4
src/sql/optimizer/ob_log_monitoring_dump.h
View File

@ -23,13 +23,13 @@ public:
ObLogMonitoringDump(ObLogPlan& plan) : ObLogicalOperator(plan), flags_(0), dst_op_line_id_(0)
{}
virtual ~ObLogMonitoringDump() = default;
const char* get_name() const;
const char* get_name() const override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int compute_op_ordering() override;
virtual int transmit_op_ordering() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est);
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int print_outline(planText& plan_text) override;
int print_tracing(planText& plan_text);
inline void set_flags(uint64_t flags)

4
src/sql/optimizer/ob_log_select_into.h
View File

@ -99,8 +99,8 @@ public:
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int transmit_op_ordering() override;
virtual uint64_t hash(uint64_t seed) const;
virtual int copy_without_child(ObLogicalOperator*& out);
virtual uint64_t hash(uint64_t seed) const override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
private:
ObItemType into_type_;

6
src/sql/optimizer/ob_log_sequence.h
View File

@ -25,9 +25,9 @@ public:
{}
virtual ~ObLogSequence()
{}
virtual uint64_t hash(uint64_t seed) const;
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual uint64_t hash(uint64_t seed) const override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
int allocate_exchange_post(AllocExchContext* ctx) override;
const common::ObIArray<uint64_t>& get_sequence_ids() const
{

12
src/sql/optimizer/ob_log_set.h
View File

@ -44,7 +44,7 @@ public:
ObSelectLogPlan* get_right_plan() const;
ObSelectStmt* get_left_stmt() const;
ObSelectStmt* get_right_stmt() const;
const char* get_name() const;
const char* get_name() const override;
inline void assign_set_distinct(const bool is_distinct)
{
is_distinct_ = is_distinct;
@ -69,7 +69,7 @@ public:
{
return is_distinct_;
}
virtual bool is_consume_child_1by1() const
virtual bool is_consume_child_1by1() const override
{
return ObSelectStmt::UNION == set_op_ && (HASH_SET == set_algo_ || !is_distinct_);
}
@ -81,10 +81,10 @@ public:
{
return set_op_;
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
int calculate_sharding_info(
ObIArray<ObRawExpr*>& left_keys, ObIArray<ObRawExpr*>& right_keys, ObShardingInfo& output_sharding);
virtual int allocate_exchange_post(AllocExchContext* ctx);
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
int get_set_child_exprs(common::ObIArray<ObRawExpr*>& left_keys, common::ObIArray<ObRawExpr*>& right_keys);
int get_calc_types(common::ObIArray<ObExprCalcType>& calc_types);
const common::ObIArray<ObOrderDirection>& get_set_directions() const
@ -112,7 +112,7 @@ public:
virtual int est_cost() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
int get_children_cost_info(ObIArray<ObBasicCostInfo>& children_cost_info);
virtual int transmit_op_ordering();
virtual int transmit_op_ordering() override;
int set_left_expected_ordering(const common::ObIArray<OrderItem>& left_expected_ordering);
int set_right_expected_ordering(const common::ObIArray<OrderItem>& right_expected_ordering);
@ -128,7 +128,7 @@ public:
int set_search_ordering(const common::ObIArray<OrderItem>& search_ordering);
int set_cycle_items(const common::ObIArray<ColumnItem>& cycle_items);
uint64_t hash(uint64_t seed) const;
uint64_t hash(uint64_t seed) const override;
const common::ObIArray<OrderItem>& get_search_ordering()
{
return search_ordering_;

16
src/sql/optimizer/ob_log_sort.h
View File

@ -100,7 +100,7 @@ public:
{
return topk_offset_count_;
}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
// @brief Set the sorting columns
int set_sort_keys(const common::ObIArray<OrderItem>& order_keys);
int check_prefix_sort();
@ -112,9 +112,9 @@ public:
int allocate_exchange(AllocExchContext* ctx, ObExchangeInfo& exch_info) override;
int push_down_sort(ObLogicalOperator* consumer_exc);
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual uint64_t hash(uint64_t seed) const;
int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual const char* get_name() const;
virtual uint64_t hash(uint64_t seed) const override;
int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual const char* get_name() const override;
int set_topk_params(
ObRawExpr* limit_count, ObRawExpr* limit_offset, int64_t minimum_row_cuont, int64_t topk_precision);
inline int64_t get_minimum_row_count() const
@ -125,21 +125,21 @@ public:
{
return topk_precision_;
}
virtual int transmit_op_ordering();
virtual int transmit_op_ordering() override;
virtual bool is_block_op() const override
{
return !is_prefix_sort();
}
virtual int compute_op_ordering() override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
virtual int generate_link_sql_pre(GenLinkStmtContext& link_ctx) override;
protected:
virtual int inner_replace_generated_agg_expr(
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*>>& to_replace_exprs);
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*>>& to_replace_exprs) override;
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
private:
common::ObSEArray<OrderItem, 8, common::ModulePageAllocator, true> sort_keys_;

18
src/sql/optimizer/ob_log_subplan_filter.h
View File

@ -30,7 +30,7 @@ public:
{}
~ObLogSubPlanFilter()
{}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
int allocate_exchange_post(AllocExchContext* ctx) override;
int check_if_match_partition_wise(const AllocExchContext& ctx, bool& is_partition_wise);
int has_serial_child(bool& has_serial_child);
@ -47,8 +47,8 @@ public:
int gen_output_columns();
virtual int est_cost() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int transmit_op_ordering();
virtual int transmit_local_ordering();
virtual int transmit_op_ordering() override;
virtual int transmit_local_ordering() override;
/**
* Get the exec params
@ -109,12 +109,12 @@ public:
int get_subquery_exprs(ObIArray<ObRawExpr*>& subquery_exprs);
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int re_calc_cost();
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int re_calc_cost() override;
int get_children_cost_info(common::ObIArray<ObBasicCostInfo>& children_cost_info);
uint64_t hash(uint64_t seed) const;
uint64_t hash(uint64_t seed) const override;
void set_update_set(bool update_set)
{
update_set_ = update_set;
@ -123,8 +123,8 @@ public:
{
return update_set_;
}
int allocate_granule_pre(AllocGIContext& ctx);
int allocate_granule_post(AllocGIContext& ctx);
int allocate_granule_pre(AllocGIContext& ctx) override;
int allocate_granule_post(AllocGIContext& ctx) override;
virtual int compute_one_row_info() override;
protected:

20
src/sql/optimizer/ob_log_subplan_scan.h
View File

@ -27,13 +27,13 @@ public:
virtual int est_cost() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int copy_without_child(ObLogicalOperator*& out);
int allocate_expr_post(ObAllocExprContext& ctx);
virtual int copy_without_child(ObLogicalOperator*& out) override;
int allocate_expr_post(ObAllocExprContext& ctx) override;
int allocate_exchange_post(AllocExchContext* ctx) override;
int update_weak_part_exprs(AllocExchContext* ctx);
int gen_filters();
int gen_output_columns();
int set_properties();
int set_properties() override;
void set_subquery_id(uint64_t subquery_id)
{
subquery_id_ = subquery_id;
@ -54,16 +54,16 @@ public:
{
return access_exprs_;
}
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int transmit_op_ordering();
virtual int transmit_local_ordering();
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int transmit_op_ordering() override;
virtual int transmit_local_ordering() override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
virtual int generate_link_sql_pre(GenLinkStmtContext& link_ctx) override;
private:
virtual int print_operator_for_outline(planText& plan_text);
virtual int is_used_join_type_hint(JoinAlgo join_algo, bool& is_used);
virtual int is_used_in_leading_hint(bool& is_used);
virtual int print_operator_for_outline(planText& plan_text) override;
virtual int is_used_join_type_hint(JoinAlgo join_algo, bool& is_used) override;
virtual int is_used_in_leading_hint(bool& is_used) override;
private:
uint64_t subquery_id_;

16
src/sql/optimizer/ob_log_table_lookup.h
View File

@ -34,15 +34,15 @@ public:
{}
virtual ~ObLogTableLookup()
{}
virtual int allocate_expr_post(ObAllocExprContext& ctx);
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int compute_property(Path* path);
virtual int compute_property(Path* path) override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int transmit_op_ordering();
virtual uint64_t hash(uint64_t seed) const;
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int transmit_op_ordering() override;
virtual uint64_t hash(uint64_t seed) const override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
inline void set_table_id(const uint64_t table_id)
{
table_id_ = table_id;
@ -95,7 +95,7 @@ public:
{
return calc_part_id_expr_;
}
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
int init_calc_part_id_expr();
int replace_gen_column(ObRawExpr* part_expr, ObRawExpr*& new_part_expr);

28
src/sql/optimizer/ob_log_table_scan.h
View File

@ -80,7 +80,7 @@ public:
virtual ~ObLogTableScan()
{}
const char* get_name() const;
const char* get_name() const override;
// not used at the moment
TO_STRING_KV(K_(table_id), K_(index_table_id), K_(is_fake_cte_table), K_(table_name), K_(index_name));
@ -330,7 +330,7 @@ public:
/**
* Copy operator and it's properties without copying its child operators
*/
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int copy_without_child(ObLogicalOperator*& out) override;
/**
* Generate the filtering expressions
@ -351,7 +351,7 @@ public:
* */
virtual int allocate_granule_post(AllocGIContext& ctx) override;
virtual int compute_property(Path* path);
virtual int compute_property(Path* path) override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
int get_index_cost(int64_t column_count, bool index_back, double& cost);
@ -360,12 +360,12 @@ public:
/**
* This function add all output columns from column items.
*/
virtual int allocate_expr_post(ObAllocExprContext& ctx);
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
/**
* Generate hash value for the operator using given seed
*/
virtual uint64_t hash(uint64_t seed) const;
virtual uint64_t hash(uint64_t seed) const override;
/**
* Get table name
@ -494,7 +494,7 @@ public:
return exist_hint_;
}
virtual int inner_replace_generated_agg_expr(
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs);
const common::ObIArray<std::pair<ObRawExpr*, ObRawExpr*> >& to_replace_exprs) override;
inline common::ObIArray<bool>& get_filter_before_index_flags()
{
return filter_before_index_back_;
@ -667,8 +667,8 @@ public:
return session_id_;
}
virtual int transmit_op_ordering();
virtual int transmit_local_ordering();
virtual int transmit_op_ordering() override;
virtual int transmit_local_ordering() override;
bool is_need_feedback() const;
int set_filters(const common::ObIArray<ObRawExpr*>& filters);
int refine_query_range();
@ -698,24 +698,24 @@ private: // member functions
int pick_out_startup_filters();
int filter_before_index_back_set();
bool is_covered(ObRelIds& rel_ids);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
// virtual int print_outline(char *buf, int64_t &buf_len, int64_t &pos, bool is_oneline);
virtual int print_outline(planText& plan_text);
virtual int print_outline(planText& plan_text) override;
int print_outline_data(planText& plan_text);
int print_all_no_index(const ObIndexHint& index_hint, planText& plan_text);
int print_single_no_index(const ObString& index_name, planText& plan_text);
int get_index_hint(bool& is_used_hint, const ObIndexHint*& index_hint);
int print_used_index(planText& plan_text);
virtual int print_operator_for_outline(planText& plan_text);
virtual int is_used_join_type_hint(JoinAlgo join_algo, bool& is_used);
virtual int is_used_in_leading_hint(bool& is_used);
virtual int print_operator_for_outline(planText& plan_text) override;
virtual int is_used_join_type_hint(JoinAlgo join_algo, bool& is_used) override;
virtual int is_used_in_leading_hint(bool& is_used) override;
int print_no_use_late_materialization(planText& plan_text);
int print_range_annotation(char* buf, int64_t buf_len, int64_t& pos, ExplainType type);
int print_filter_before_indexback_annotation(char* buf, int64_t buf_len, int64_t& pos);
int print_limit_offset_annotation(char* buf, int64_t buf_len, int64_t& pos, ExplainType type);
int print_ranges(char* buf, int64_t buf_len, int64_t& pos, const ObIArray<ObNewRange>& ranges);
int print_split_range_annotation(char* buf, int64_t buf_len, int64_t& pos, ExplainType type);
virtual int explain_index_selection_info(char* buf, int64_t& buf_len, int64_t& pos);
virtual int explain_index_selection_info(char* buf, int64_t& buf_len, int64_t& pos) override;
int generate_part_filter(ObRawExpr*& part_filter_expr);
int fill_link_stmt(
const common::ObIArray<ObRawExpr*>& select_strs, const TableItem& table_item, ObLinkStmt& link_stmt);

6
src/sql/optimizer/ob_log_temp_table_access.h
View File

@ -24,7 +24,7 @@ class ObLogTempTableAccess : public ObLogicalOperator {
public:
ObLogTempTableAccess(ObLogPlan& plan);
virtual ~ObLogTempTableAccess();
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
return clone(out);
}
@ -59,7 +59,7 @@ public:
{
return is_last_access_;
}
int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
inline common::ObString& get_table_name()
{
return temp_table_name_;
@ -72,7 +72,7 @@ public:
{
return access_exprs_;
}
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
private:
DISALLOW_COPY_AND_ASSIGN(ObLogTempTableAccess);

2
src/sql/optimizer/ob_log_temp_table_insert.h
View File

@ -25,7 +25,7 @@ public:
ObLogTempTableInsert(ObLogPlan& plan);
virtual ~ObLogTempTableInsert();
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
return clone(out);
}

2
src/sql/optimizer/ob_log_temp_table_transformation.h
View File

@ -30,7 +30,7 @@ public:
virtual int allocate_exchange(AllocExchContext* ctx, ObExchangeInfo& exch_info) override;
virtual int compute_op_ordering() override;
virtual int transmit_local_ordering() override;
virtual bool is_consume_child_1by1() const
virtual bool is_consume_child_1by1() const override
{
return true;
}

10
src/sql/optimizer/ob_log_topk.h
View File

@ -49,11 +49,11 @@ public:
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int allocate_exchange(AllocExchContext* ctx, bool parts_order);
virtual uint64_t hash(uint64_t seed) const;
virtual int copy_without_child(ObLogicalOperator*& out);
int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual uint64_t hash(uint64_t seed) const override;
virtual int copy_without_child(ObLogicalOperator*& out) override;
int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
private:
int64_t minimum_row_count_;

12
src/sql/optimizer/ob_log_unpivot.h
View File

@ -26,9 +26,9 @@ public:
~ObLogUnpivot()
{}
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int allocate_expr_post(ObAllocExprContext& ctx);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int allocate_expr_post(ObAllocExprContext& ctx) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
int allocate_exchange_post(AllocExchContext* ctx) override;
int calc_cost();
@ -36,7 +36,7 @@ public:
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
int gen_filters();
int gen_output_columns();
int set_properties();
int set_properties() override;
void set_subquery_id(uint64_t subquery_id)
{
subquery_id_ = subquery_id;
@ -57,8 +57,8 @@ public:
{
return access_exprs_;
}
virtual int transmit_op_ordering();
virtual int transmit_local_ordering();
virtual int transmit_op_ordering() override;
virtual int transmit_local_ordering() override;
virtual int compute_op_ordering() override;
virtual int compute_fd_item_set() override;

16
src/sql/optimizer/ob_log_update.h
View File

@ -33,15 +33,15 @@ public:
return tables_assignments_;
}
virtual int copy_without_child(ObLogicalOperator*& out);
int allocate_exchange_post(AllocExchContext* ctx);
virtual int copy_without_child(ObLogicalOperator*& out) override;
int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int est_cost();
virtual int est_cost() override;
virtual uint64_t hash(uint64_t seed) const;
virtual uint64_t hash(uint64_t seed) const override;
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker);
virtual const char* get_name() const;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
virtual const char* get_name() const override;
void set_update_set(bool update_set)
{
update_set_ = update_set;
@ -51,10 +51,10 @@ public:
return update_set_;
}
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const;
virtual int inner_append_not_produced_exprs(ObRawExprUniqueSet& raw_exprs) const override;
private:
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
int get_update_table(ObDMLStmt* stmt, ObColumnRefRawExpr* col_expr, uint64_t& ref_id);

6
src/sql/optimizer/ob_log_values.h
View File

@ -30,12 +30,12 @@ public:
{}
virtual ~ObLogValues()
{}
virtual int allocate_exchange_post(AllocExchContext* ctx)
virtual int allocate_exchange_post(AllocExchContext* ctx) override
{
UNUSED(ctx);
return common::OB_SUCCESS;
}
virtual int copy_without_child(ObLogicalOperator*& out)
virtual int copy_without_child(ObLogicalOperator*& out) override
{
out = NULL;
return common::OB_SUCCESS;
@ -64,7 +64,7 @@ public:
{
return row_store_;
}
uint64_t hash(uint64_t seed) const
uint64_t hash(uint64_t seed) const override
{
if (NULL != explain_plan_) {
seed = do_hash(*explain_plan_, seed);

8
src/sql/optimizer/ob_log_window_function.h
View File

@ -23,8 +23,8 @@ public:
virtual ~ObLogWindowFunction()
{}
virtual int allocate_exchange_post(AllocExchContext* ctx) override;
virtual int copy_without_child(ObLogicalOperator*& out);
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type);
virtual int copy_without_child(ObLogicalOperator*& out) override;
virtual int print_my_plan_annotation(char* buf, int64_t& buf_len, int64_t& pos, ExplainType type) override;
inline int add_window_expr(ObWinFunRawExpr* win_expr)
{
@ -36,12 +36,12 @@ public:
}
virtual int est_cost() override;
virtual int re_est_cost(const ObLogicalOperator* parent, double need_row_count, bool& re_est) override;
virtual int transmit_op_ordering();
virtual int transmit_op_ordering() override;
virtual int allocate_expr_pre(ObAllocExprContext& ctx) override;
virtual int check_output_dep_specific(ObRawExprCheckDep& checker) override;
int is_my_window_expr(const ObRawExpr* expr, bool& is_mine);
virtual bool is_block_op() const override;
virtual uint64_t hash(uint64_t seed) const;
virtual uint64_t hash(uint64_t seed) const override;
virtual int allocate_granule_post(AllocGIContext& ctx) override;
virtual int allocate_granule_pre(AllocGIContext& ctx) override;
int get_win_partition_intersect_exprs(ObIArray<ObWinFunRawExpr*>& win_exprs, ObIArray<ObRawExpr*>& win_part_exprs);

8
src/sql/resolver/dml/ob_del_upd_stmt.h
View File

@ -259,7 +259,7 @@ public:
{
has_global_index_ |= has_global_index;
}
virtual bool check_table_be_modified(uint64_t ref_table_id) const;
virtual bool check_table_be_modified(uint64_t ref_table_id) const override;
void set_dml_source_from_join(bool from_join)
{
dml_source_from_join_ = from_join;
@ -270,7 +270,7 @@ public:
}
virtual int update_base_tid_cid();
virtual int inner_get_share_exprs(ObIArray<ObRawExpr*>& candi_share_exprs) const;
virtual int inner_get_share_exprs(ObIArray<ObRawExpr*>& candi_share_exprs) const override;
virtual int replace_inner_stmt_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
uint64_t get_insert_table_id(uint64_t table_offset = 0) const;
@ -278,8 +278,8 @@ public:
uint64_t get_ref_table_id() const;
protected:
int inner_get_relation_exprs(RelExprCheckerBase& expr_checker);
virtual int inner_get_relation_exprs_for_wrapper(RelExprChecker& expr_checker)
int inner_get_relation_exprs(RelExprCheckerBase& expr_checker) override;
virtual int inner_get_relation_exprs_for_wrapper(RelExprChecker& expr_checker) override
{
return ObDelUpdStmt::inner_get_relation_exprs(expr_checker);
}

6
src/sql/resolver/dml/ob_insert_stmt.h
View File

@ -195,7 +195,7 @@ public:
is_all_const_values_ = is_all_const;
}
// is used to replace all references to from expr in stmt
virtual int replace_expr_in_stmt(ObRawExpr* from, ObRawExpr* to);
virtual int replace_expr_in_stmt(ObRawExpr* from, ObRawExpr* to) override;
int64_t get_value_index(uint64_t table_id, uint64_t column_id) const;
const ObUniqueConstraintCheckStmt& get_constraint_check_stmt() const
{
@ -294,9 +294,9 @@ public:
protected:
// Get the root expr of all query-related expressions in
// stmt (expression generated by the attributes specified in the query statement)
virtual int inner_get_relation_exprs(RelExprCheckerBase& expr_checker);
virtual int inner_get_relation_exprs(RelExprCheckerBase& expr_checker) override;
// get the root expr that needs to be processed by enum_set_wrapper in stmt
virtual int inner_get_relation_exprs_for_wrapper(RelExprChecker& expr_checker);
virtual int inner_get_relation_exprs_for_wrapper(RelExprChecker& expr_checker) override;
int replace_dupkey_exprs(const common::ObIArray<ObRawExpr*>& other_exprs,
const common::ObIArray<ObRawExpr*>& new_exprs, ObDupKeyScanInfo& scan_info);

24
src/sql/resolver/dml/ob_select_stmt.h
View File

@ -620,7 +620,7 @@ public:
}
int get_select_exprs(ObIArray<ObRawExpr*>& select_exprs, const bool is_for_outout = false);
int get_select_exprs(ObIArray<ObRawExpr*>& select_exprs, const bool is_for_outout = false) const;
int inner_get_share_exprs(ObIArray<ObRawExpr*>& candi_share_exprs) const;
int inner_get_share_exprs(ObIArray<ObRawExpr*>& candi_share_exprs) const override;
const common::ObIArray<ObAggFunRawExpr*>& get_aggr_items() const
{
return agg_items_;
@ -783,7 +783,7 @@ public:
{
return for_update_columns_;
}
virtual bool is_affect_found_rows() const
virtual bool is_affect_found_rows() const override
{
bool ret = false;
if (select_type_ == AFFECT_FOUND_ROWS) {
@ -793,7 +793,7 @@ public:
}
return ret;
}
virtual bool has_link_table() const
virtual bool has_link_table() const override
{
bool bret = ObDMLStmt::has_link_table();
for (int64_t i = 0; !bret && i < set_query_.count(); i++) {
@ -835,7 +835,7 @@ public:
bool is_mix_of_group_func_and_fileds() const;
// replace expression from %from to %to, only replace expr pointer of stmt,
// will not recursive replace of expr
virtual int replace_expr_in_stmt(ObRawExpr* from, ObRawExpr* to);
virtual int replace_expr_in_stmt(ObRawExpr* from, ObRawExpr* to) override;
void set_star_select()
{
is_select_star_ = true;
@ -856,14 +856,14 @@ public:
{
return is_match_topk_;
}
virtual bool is_set_stmt() const
virtual bool is_set_stmt() const override
{
return NONE != set_op_;
}
int get_child_stmt_size(int64_t& child_size) const;
int get_child_stmts(common::ObIArray<ObSelectStmt*>& child_stmts) const;
int set_child_stmt(const int64_t child_num, ObSelectStmt* child_stmt);
int get_from_subquery_stmts(common::ObIArray<ObSelectStmt*>& child_stmts) const;
int get_child_stmt_size(int64_t& child_size) const override;
int get_child_stmts(common::ObIArray<ObSelectStmt*>& child_stmts) const override;
int set_child_stmt(const int64_t child_num, ObSelectStmt* child_stmt) override;
int get_from_subquery_stmts(common::ObIArray<ObSelectStmt*>& child_stmts) const override;
const common::ObIArray<ObWinFunRawExpr*>& get_window_func_exprs() const
{
return win_func_exprs_;
@ -962,7 +962,7 @@ public:
{
return get_sample_info_by_table_id(table_id) != nullptr;
}
virtual bool check_table_be_modified(uint64_t ref_table_id) const;
virtual bool check_table_be_modified(uint64_t ref_table_id) const override;
// check aggregation has distinct or group concat e.g.:
// count(distinct c1)
@ -1018,8 +1018,8 @@ private:
const ObIArray<ObMultiRollupItem>& multi_rollup_items, const ObExprInfoFlag flag, bool& has) const;
protected:
virtual int inner_get_relation_exprs(RelExprCheckerBase& expr_checker);
virtual int inner_get_relation_exprs_for_wrapper(RelExprChecker& expr_checker)
virtual int inner_get_relation_exprs(RelExprCheckerBase& expr_checker) override;
virtual int inner_get_relation_exprs_for_wrapper(RelExprChecker& expr_checker) override
{
return inner_get_relation_exprs(expr_checker);
}

196
src/sql/resolver/expr/ob_raw_expr.h
View File

@ -1677,7 +1677,7 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObConstRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
void set_value(const oceanbase::common::ObObj& val);
void set_literal_prefix(const common::ObString& name);
void set_expr_obj_meta(const common::ObObjMeta& meta)
@ -1698,13 +1698,13 @@ public:
{
return true == is_date_unit_;
}
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
DECLARE_VIRTUAL_TO_STRING;
private:
@ -1741,12 +1741,12 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObVarRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
void set_result_type_assigned(bool v)
{
result_type_assigned_ = v;
@ -1779,13 +1779,13 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObUserVarIdentRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
bool get_is_contain_assign() const
{
@ -1860,7 +1860,7 @@ public:
int assign(const ObQueryRefRawExpr& other);
int deep_copy(ObStmtFactory& stmt_factory, ObRawExprFactory& expr_factory, const ObQueryRefRawExpr& other);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
int64_t get_ref_id() const;
void set_ref_id(int64_t id);
ObSelectStmt* get_ref_stmt();
@ -1892,7 +1892,7 @@ public:
return OB_LOGICAL_OPERATOR == ref_type_;
}
void set_output_column(int64_t output_column);
int64_t get_output_column() const;
int64_t get_output_column() const override;
int add_column_type(const ObExprResType& type)
{
return column_types_.push_back(type);
@ -1921,17 +1921,17 @@ public:
{
return is_cursor_;
}
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const
virtual uint64_t hash_internal(uint64_t seed) const override
{
return common::do_hash(ref_id_, seed);
}
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, N_ID,
ref_id_, K_(expr_level), K_(expr_levels), K_(output_column), K_(is_set), K_(is_cursor), K_(column_types),
K_(enum_set_values));
@ -2044,7 +2044,7 @@ public:
int assign(const ObColumnRefRawExpr& other);
int deep_copy(ObRawExprFactory& expr_factory, const ObColumnRefRawExpr& other, bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
uint64_t get_table_id() const;
uint64_t get_column_id() const;
uint64_t& get_table_id();
@ -2116,12 +2116,12 @@ public:
{
return get_column_id();
}
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
bool is_from_alias_table() const { return from_alias_table_; }
void set_from_alias_table(bool value) { from_alias_table_ = value; }
@ -2211,7 +2211,7 @@ public:
real_expr_ = expr;
}
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, N_TID,
table_id_, N_CID, column_id_, K_(database_name), K_(table_name), K_(synonym_name), K_(synonym_db_name),
@ -2283,8 +2283,8 @@ public:
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
int deep_copy(
ObRawExprFactory& expr_factory, const ObSetOpRawExpr& other, const uint64_t copy_types, bool use_new_allocator);
@ -2325,7 +2325,7 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObAliasRefRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
const ObRawExpr* get_ref_expr() const;
ObRawExpr* get_ref_expr();
void set_ref_expr(ObRawExpr* ref_expr)
@ -2357,9 +2357,9 @@ public:
virtual const ObRawExpr* get_param_expr(int64_t index) const override;
virtual ObRawExpr*& get_param_expr(int64_t index) override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, N_VALUE,
ref_expr_, K_(enum_set_values));
@ -2385,8 +2385,8 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObNonTerminalRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
virtual void reset()
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
virtual void reset() override
{
free_op();
input_types_.reset();
@ -2408,7 +2408,7 @@ public:
return input_types_.count();
}
virtual uint64_t hash_internal(uint64_t seed) const
virtual uint64_t hash_internal(uint64_t seed) const override
{
return seed;
}
@ -2452,7 +2452,7 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObOpRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
int set_param_expr(ObRawExpr* expr); // unary op
int set_param_exprs(ObRawExpr* first_expr, ObRawExpr* second_expr); // binary op
int set_param_exprs(ObRawExpr* first_expr, ObRawExpr* second_expr, ObRawExpr* third_expr); // triple op
@ -2480,25 +2480,25 @@ public:
return exprs_;
}
int64_t get_param_count() const;
const ObRawExpr* get_param_expr(int64_t index) const;
ObRawExpr*& get_param_expr(int64_t index);
virtual int64_t get_output_column() const
int64_t get_param_count() const override;
const ObRawExpr* get_param_expr(int64_t index) const override;
ObRawExpr*& get_param_expr(int64_t index) override;
virtual int64_t get_output_column() const override
{
return T_OP_ROW == get_expr_type() ? get_param_count() : -1;
}
virtual void clear_child();
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void clear_child() override;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
// used for jit expr
virtual int64_t get_children_count() const
virtual int64_t get_children_count() const override
{
return exprs_.count();
}
// used for jit expr
virtual int get_children(jit::expr::ExprArray& jit_exprs) const;
virtual int get_children(jit::expr::ExprArray& jit_exprs) const override;
void set_subquery_key(ObSubQueryKey& key)
{
@ -2511,9 +2511,9 @@ public:
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
int get_subquery_comparison_name(
const common::ObString& symbol, char* buf, int64_t buf_len, int64_t& pos, ExplainType type) const;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
@ -2628,7 +2628,7 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObCaseOpRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
const ObRawExpr* get_arg_param_expr() const;
const ObRawExpr* get_default_param_expr() const;
const ObRawExpr* get_when_param_expr(int64_t index) const;
@ -2663,27 +2663,27 @@ public:
return is_decode_func_;
}
virtual void clear_child();
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void clear_child() override;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual int64_t get_param_count() const;
virtual const ObRawExpr* get_param_expr(int64_t index) const;
virtual ObRawExpr*& get_param_expr(int64_t index);
virtual int64_t get_param_count() const override;
virtual const ObRawExpr* get_param_expr(int64_t index) const override;
virtual ObRawExpr*& get_param_expr(int64_t index) override;
// used for jit
virtual int64_t get_children_count() const
virtual int64_t get_children_count() const override
{
return get_param_count();
}
virtual int get_children(jit::expr::ExprArray& jit_exprs) const;
virtual int get_children(jit::expr::ExprArray& jit_exprs) const override;
virtual uint64_t hash_internal(uint64_t seed) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_levels), N_ARG_CASE, arg_expr_, N_DEFAULT, default_expr_, N_WHEN, when_exprs_, N_THEN, then_exprs_,
N_DECODE, is_decode_func_);
@ -2889,7 +2889,7 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObAggFunRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
int add_real_param_expr(ObRawExpr* expr);
int replace_real_param_expr(int64_t index, ObRawExpr* expr);
int replace_param_expr(int64_t index, ObRawExpr* expr);
@ -2903,16 +2903,16 @@ public:
bool is_nested_aggr() const;
void set_in_nested_aggr(bool is_nested);
int add_order_item(const OrderItem& order_item);
virtual void clear_child();
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void clear_child() override;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int64_t get_param_count() const
virtual int64_t get_param_count() const override
{
return real_param_exprs_.count() + order_items_.count();
}
virtual const ObRawExpr* get_param_expr(int64_t index) const;
virtual ObRawExpr*& get_param_expr(int64_t index);
virtual const ObRawExpr* get_param_expr(int64_t index) const override;
virtual ObRawExpr*& get_param_expr(int64_t index) override;
inline int64_t get_real_param_count() const
{
return real_param_exprs_.count();
@ -2955,7 +2955,7 @@ public:
return order_items_;
}
virtual uint64_t hash_internal(uint64_t seed) const
virtual uint64_t hash_internal(uint64_t seed) const override
{
for (int64_t i = 0; i < real_param_exprs_.count(); ++i) {
if (OB_LIKELY(NULL != real_param_exprs_.at(i))) {
@ -2979,7 +2979,7 @@ public:
return udf_meta_;
}
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
const char* get_name_dblink(ObItemType expr_type) const;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_level), K_(expr_levels), N_CHILDREN, real_param_exprs_, N_DISTINCT, distinct_, N_ORDER_BY, order_items_,
@ -3114,21 +3114,21 @@ public:
bool use_new_allocator = false);
void set_func_name(const common::ObString& name);
const common::ObString& get_func_name() const;
virtual void clear_child();
virtual void clear_child() override;
int check_param_num();
virtual ObExprOperator* get_op();
virtual void reset();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual ObExprOperator* get_op() override;
virtual void reset() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const
virtual uint64_t hash_internal(uint64_t seed) const override
{
uint64_t hash_ret = common::do_hash(func_name_, seed);
return hash_ret;
}
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
int get_cast_type_name(char* buf, int64_t buf_len, int64_t& pos) const;
int get_column_conv_name(char* buf, int64_t buf_len, int64_t& pos, ExplainType type) const;
void set_op_id(int64_t operator_id)
@ -3404,9 +3404,9 @@ public:
virtual ~ObFunMatchAgainst()
{}
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
inline void set_mode_flag(ObMatchAgainstMode mode_flag)
{
mode_flag_ = mode_flag;
@ -3461,15 +3461,15 @@ public:
{
return fulltext_filter_;
}
int64_t get_param_count() const
int64_t get_param_count() const override
{
return 2;
}
const ObRawExpr* get_param_expr(int64_t index) const;
ObRawExpr*& get_param_expr(int64_t index);
void clear_child();
const ObRawExpr* get_param_expr(int64_t index) const override;
ObRawExpr*& get_param_expr(int64_t index) override;
void clear_child() override;
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
VIRTUAL_TO_STRING_KV(
N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, K_(mode_flag));
@ -3496,13 +3496,13 @@ public:
virtual ~ObSetIterRawExpr()
{}
virtual int do_visit(ObRawExprVisitor& visitor) override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int64_t get_param_count() const
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
int64_t get_param_count() const override
{
return 2;
}
const ObRawExpr* get_param_expr(int64_t index) const;
ObRawExpr*& get_param_expr(int64_t index);
const ObRawExpr* get_param_expr(int64_t index) const override;
ObRawExpr*& get_param_expr(int64_t index) override;
void set_left_expr(ObRawExpr* left_iter)
{
left_iter_ = left_iter;
@ -3511,13 +3511,13 @@ public:
{
right_iter_ = right_iter;
}
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override
{
UNUSED(expr);
UNUSED(check_context);
return false;
}
inline void clear_child()
inline void clear_child() override
{
left_iter_ = NULL;
right_iter_ = NULL;
@ -3544,13 +3544,13 @@ public:
virtual ~ObRowIterRawExpr()
{}
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override
{
UNUSED(expr);
UNUSED(check_context);
return false;
}
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
inline void set_iter_idx(int64_t iter_idx)
{
iter_idx_ = iter_idx;
@ -3755,7 +3755,7 @@ public:
bool use_new_allocator = false);
int replace_param_expr(int64_t partition_expr_index, ObRawExpr* expr);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
inline void set_func_type(ObItemType func_type)
{
func_type_ = func_type;
@ -3813,10 +3813,10 @@ public:
return agg_expr_;
}
virtual void clear_child();
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
virtual void clear_child() override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int64_t get_param_count() const
virtual int64_t get_param_count() const override
{
int64_t cnt = (agg_expr_ != NULL ? agg_expr_->get_param_count() : 0) + func_params_.count() +
partition_exprs_.count() + order_items_.count() + (upper_.interval_expr_ != NULL ? 1 : 0) +
@ -3831,13 +3831,13 @@ public:
}
return cnt;
}
virtual const ObRawExpr* get_param_expr(int64_t index) const;
virtual ObRawExpr*& get_param_expr(int64_t index);
virtual const ObRawExpr* get_param_expr(int64_t index) const override;
virtual ObRawExpr*& get_param_expr(int64_t index) override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_level), K_(expr_levels), K_(func_type), K_(is_distinct), K_(func_params), K_(partition_exprs),
K_(order_items), K_(win_type), K_(is_between), K_(upper), K_(lower), KPC_(agg_expr));
@ -3871,12 +3871,12 @@ public:
int deep_copy(ObRawExprFactory& expr_factory, const ObPseudoColumnRawExpr& other, const uint64_t copy_types,
bool use_new_allocator = false);
virtual int replace_expr(
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs);
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const;
const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int do_visit(ObRawExprVisitor& visitor) override;
virtual uint64_t hash_internal(uint64_t seed) const;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
virtual uint64_t hash_internal(uint64_t seed) const override;
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
bool is_hierarchical_query_type() const
{
return type_ == T_LEVEL || type_ == T_CONNECT_BY_ISCYCLE || type_ == T_CONNECT_BY_ISLEAF;

6
src/storage/blocksstable/ob_micro_block_row_scanner.h
View File

@ -126,7 +126,7 @@ public:
const storage::ObSSTable* sstable) override;
virtual int open(const MacroBlockId& macro_id, const ObFullMacroBlockMeta& macro_meta,
const ObMicroBlockData& block_data, const bool is_left_border, const bool is_right_border) override;
void reset();
void reset() override;
protected:
virtual int inner_get_next_row(const storage::ObStoreRow*& row) override;
@ -195,7 +195,7 @@ public:
const storage::ObSSTable* sstable) override;
virtual int open(const MacroBlockId& macro_id, const ObFullMacroBlockMeta& macro_meta,
const ObMicroBlockData& block_data, const bool is_left_border, const bool is_right_border) override;
void reset();
void reset() override;
void rescan() override;
protected:
@ -248,7 +248,7 @@ public:
const storage::ObSSTable* sstable) override;
virtual int open(const MacroBlockId& macro_id, const ObFullMacroBlockMeta& macro_meta,
const ObMicroBlockData& block_data, const bool is_left_border, const bool is_right_border) override;
void reset();
void reset() override;
void rescan() override
{
reset();

10
src/storage/compaction/ob_partition_merge.h
View File

@ -136,7 +136,7 @@ public:
KP_(table_schema), K_(need_fuse_generate));
protected:
virtual int inner_check_merge_param(const storage::ObMergeParameter& merge_param);
virtual int inner_check_merge_param(const storage::ObMergeParameter& merge_param) override;
virtual int inner_init(const storage::ObMergeParameter& merge_param) override;
virtual int fuse_generate_exprs();
virtual int fuse_old_row(ObMacroRowIterator* row_iter, storage::ObStoreRow* row);
@ -205,9 +205,9 @@ public:
virtual ~ObMinorPartitionMergeFuser();
virtual void reset() override;
virtual bool is_valid() const override;
virtual int fuse_row(MERGE_ITER_ARRAY& macro_row_iters) = 0;
virtual int fuse_row(MERGE_ITER_ARRAY& macro_row_iters) override = 0;
virtual int find_minimum_iters(const MERGE_ITER_ARRAY& macro_row_iters, MERGE_ITER_ARRAY& minimum_iters) override;
virtual inline const common::ObIArray<share::schema::ObColDesc>& get_column_ids() const
virtual inline const common::ObIArray<share::schema::ObColDesc>& get_column_ids() const override
{
return column_ids_;
}
@ -230,8 +230,8 @@ protected:
int set_multi_version_row_flag(const MERGE_ITER_ARRAY& macro_row_iters, storage::ObStoreRow& store_row);
void set_dml(const MERGE_ITER_ARRAY& macro_row_iters, storage::ObStoreRow& store_row);
virtual int fuse_delete_row(
ObMacroRowIterator* row_iter, storage::ObStoreRow* row, const int64_t rowkey_column_cnt) = 0;
virtual int malloc_row(int64_t column_count, storage::ObStoreRow*& row) = 0;
ObMacroRowIterator* row_iter, storage::ObStoreRow* row, const int64_t rowkey_column_cnt) override = 0;
virtual int malloc_row(int64_t column_count, storage::ObStoreRow*& row) override = 0;
bool is_committed_row_(const storage::ObStoreRow& row) const;
protected:

28
src/storage/compaction/ob_partition_merge_builder.h
View File

@ -75,16 +75,16 @@ public:
const ObIArray<share::schema::ObColDesc>& column_ids,
const ObIArray<blocksstable::ObMacroBlockInfoPair>* lob_blocks = NULL) override;
virtual int init_bloomfilter_if_need(storage::ObSSTableMergeCtx& ctx);
virtual int process(const blocksstable::ObMacroBlockCtx& macro_block_ctx);
virtual int process(const blocksstable::ObMicroBlock& micro_block);
virtual int process(const storage::ObStoreRow& row, const ObCompactRowType::ObCompactRowTypeEnum type);
virtual int close();
virtual void reset();
virtual const blocksstable::ObDataStoreDesc* get_data_store_desc() const
virtual int process(const blocksstable::ObMacroBlockCtx& macro_block_ctx) override;
virtual int process(const blocksstable::ObMicroBlock& micro_block) override;
virtual int process(const storage::ObStoreRow& row, const ObCompactRowType::ObCompactRowTypeEnum type) override;
virtual int close() override;
virtual void reset() override;
virtual const blocksstable::ObDataStoreDesc* get_data_store_desc() const override
{
return &desc_;
}
virtual void set_purged_count(const int64_t count);
virtual void set_purged_count(const int64_t count) override;
TO_STRING_KV(K_(desc), K_(sstable_merge_info), K_(writer));
protected:
@ -125,20 +125,20 @@ public:
virtual int open(storage::ObSSTableMergeCtx& ctx, const int64_t idx, const bool iter_complement,
const ObIArray<share::schema::ObColDesc>& column_ids,
const ObIArray<blocksstable::ObMacroBlockInfoPair>* lob_blocks = NULL) override;
virtual int process(const blocksstable::ObMacroBlockCtx& macro_block_ctx);
virtual int process(const blocksstable::ObMicroBlock& micro_block);
virtual int process(const storage::ObStoreRow& row, const ObCompactRowType::ObCompactRowTypeEnum type);
virtual int close();
virtual void reset();
virtual int process(const blocksstable::ObMacroBlockCtx& macro_block_ctx) override;
virtual int process(const blocksstable::ObMicroBlock& micro_block) override;
virtual int process(const storage::ObStoreRow& row, const ObCompactRowType::ObCompactRowTypeEnum type) override;
virtual int close() override;
virtual void reset() override;
OB_INLINE void set_component(ObIStoreRowProcessor* component)
{
component_ = component;
}
virtual const blocksstable::ObDataStoreDesc* get_data_store_desc() const
virtual const blocksstable::ObDataStoreDesc* get_data_store_desc() const override
{
return is_opened_ ? component_->get_data_store_desc() : NULL;
}
virtual void set_purged_count(const int64_t count);
virtual void set_purged_count(const int64_t count) override;
TO_STRING_KV(KP(component_));
private:

2
src/storage/ob_long_ops_monitor.h
View File

@ -108,7 +108,7 @@ struct ObCreateIndexKey : public ObILongOpsKey {
virtual ~ObCreateIndexKey()
{}
virtual int to_key_string() override;
bool is_valid() const
bool is_valid() const override
{
return common::OB_INVALID_ID != index_table_id_ && common::OB_INVALID_ID != partition_id_;
}

8
src/storage/ob_old_sstable.h
View File

@ -110,7 +110,7 @@ public:
virtual int open(const ObCreateSSTableParam& param);
virtual int open(const blocksstable::ObSSTableBaseMeta& meta);
virtual int close();
virtual void destroy();
virtual void destroy() override;
// if set success, src ObMacroBlocksWriteCtx will be clear
// if set failed, dest sstable macro blocks will be clear
@ -264,9 +264,9 @@ public:
const int64_t type, uint64_t* macros_count, const int64_t* total_task_count,
common::ObIArray<common::ObStoreRange>* splitted_ranges, common::ObIArray<int64_t>* split_index);
int exist(const ObStoreCtx& ctx, const uint64_t table_id, const common::ObStoreRowkey& rowkey,
const common::ObIArray<share::schema::ObColDesc>& column_ids, bool& is_exist, bool& has_found);
virtual int prefix_exist(storage::ObRowsInfo& rows_info, bool& may_exist);
int exist(ObRowsInfo& rows_info, bool& is_exist, bool& all_rows_found);
const common::ObIArray<share::schema::ObColDesc>& column_ids, bool& is_exist, bool& has_found) override;
virtual int prefix_exist(storage::ObRowsInfo& rows_info, bool& may_exist) override;
int exist(ObRowsInfo& rows_info, bool& is_exist, bool& all_rows_found) override;
int64_t get_occupy_size() const
{
return meta_.occupy_size_;

10
src/storage/ob_partition_service.h
View File

@ -320,7 +320,7 @@ public:
VIRTUAL_FOR_UNITTEST int start();
VIRTUAL_FOR_UNITTEST int stop();
VIRTUAL_FOR_UNITTEST int wait();
VIRTUAL_FOR_UNITTEST int destroy();
VIRTUAL_FOR_UNITTEST int destroy() override;
VIRTUAL_FOR_UNITTEST int wait_start_finish();
@ -691,10 +691,10 @@ public:
common::ObIArray<int64_t>* split_index) override;
virtual int get_multi_ranges_cost(
const common::ObPartitionKey& pkey, const common::ObIArray<common::ObStoreRange>& ranges, int64_t& total_size);
const common::ObPartitionKey& pkey, const common::ObIArray<common::ObStoreRange>& ranges, int64_t& total_size) override;
virtual int split_multi_ranges(const common::ObPartitionKey& pkey,
const common::ObIArray<common::ObStoreRange>& ranges, const int64_t expected_task_count,
common::ObIAllocator& allocator, common::ObArrayArray<common::ObStoreRange>& multi_range_split_array);
common::ObIAllocator& allocator, common::ObArrayArray<common::ObStoreRange>& multi_range_split_array) override;
VIRTUAL_FOR_UNITTEST int is_log_sync(
const common::ObPartitionKey& key, bool& is_sync, uint64_t& max_confirmed_log_id);
VIRTUAL_FOR_UNITTEST int set_region(const ObPartitionKey& key, clog::ObIPartitionLogService* pls);
@ -796,8 +796,8 @@ public:
int check_physical_flashback_succ(
const obrpc::ObCheckPhysicalFlashbackArg& arg, obrpc::ObPhysicalFlashbackResultArg& result);
int nonblock_renew_loc_cache(const common::ObPartitionKey& pkey);
int submit_pt_update_task(const ObPartitionKey& pkey);
int submit_pt_update_role_task(const ObPartitionKey& pkey);
int submit_pt_update_task(const ObPartitionKey& pkey) override;
int submit_pt_update_role_task(const ObPartitionKey& pkey) override;
int start_physical_flashback();
int check_can_physical_flashback();
int try_freeze_aggre_buffer(const common::ObPartitionKey& pkey);

32
src/storage/ob_partition_storage.h
View File

@ -355,8 +355,8 @@ public:
virtual int lock(const ObStoreCtx& ctx) override;
virtual void set_merge_status(bool merge_success);
virtual bool can_schedule_merge();
virtual void set_merge_status(bool merge_success) override;
virtual bool can_schedule_merge() override;
// write ssstore objects @version tree to data file, used by write_check_point
virtual int serialize(ObArenaAllocator& allocator, char*& new_buf, int64_t& serialize_size);
@ -364,27 +364,27 @@ public:
virtual int deserialize(const ObReplicaType replica_type, const char* buf, const int64_t buf_len,
ObIPartitionGroup* pg, int64_t& pos, bool& is_old_meta, ObPartitionStoreMeta& old_meta);
virtual bool has_memstore();
virtual bool has_memstore() override;
// freeze actions
virtual int get_replayed_table_version(int64_t& table_version);
virtual int get_partition_ss_store_info(common::ObArray<PartitionSSStoreInfo>& partition_ss_store_info_list);
virtual int get_all_tables(ObTablesHandle& tables_handle);
virtual int retire_warmup_store(const bool is_disk_full);
virtual int halt_prewarm();
virtual int get_replayed_table_version(int64_t& table_version) override;
virtual int get_partition_ss_store_info(common::ObArray<PartitionSSStoreInfo>& partition_ss_store_info_list) override;
virtual int get_all_tables(ObTablesHandle& tables_handle) override;
virtual int retire_warmup_store(const bool is_disk_full) override;
virtual int halt_prewarm() override;
virtual common::ObReplicaType get_replica_type()
virtual common::ObReplicaType get_replica_type() override
{
return store_.get_replica_type();
}
virtual int query_range_to_macros(common::ObIAllocator& allocator,
const common::ObIArray<common::ObStoreRange>& ranges, const int64_t type, uint64_t* macros_count,
const int64_t* total_task_count, common::ObIArray<common::ObStoreRange>* splitted_ranges,
common::ObIArray<int64_t>* split_index);
virtual int get_multi_ranges_cost(const common::ObIArray<common::ObStoreRange>& ranges, int64_t& total_size);
common::ObIArray<int64_t>* split_index) override;
virtual int get_multi_ranges_cost(const common::ObIArray<common::ObStoreRange>& ranges, int64_t& total_size) override;
virtual int split_multi_ranges(const common::ObIArray<common::ObStoreRange>& ranges,
const int64_t expected_task_count, common::ObIAllocator& allocator,
common::ObArrayArray<common::ObStoreRange>& multi_range_split_array);
common::ObArrayArray<common::ObStoreRange>& multi_range_split_array) override;
virtual int append_local_sort_data(const share::ObBuildIndexAppendLocalDataParam& param,
const common::ObPGKey& pg_key, const blocksstable::ObStorageFileHandle& file_handle,
common::ObNewRowIterator& iter) override;
@ -418,12 +418,12 @@ public:
{
return store_;
}
int do_warm_up_request(const ObIWarmUpRequest* request);
int check_index_need_build(const share::schema::ObTableSchema& index_schema, bool& need_build);
int get_build_index_context(const compaction::ObBuildIndexParam& param, compaction::ObBuildIndexContext& context);
int do_warm_up_request(const ObIWarmUpRequest* request) override;
int check_index_need_build(const share::schema::ObTableSchema& index_schema, bool& need_build) override;
int get_build_index_context(const compaction::ObBuildIndexParam& param, compaction::ObBuildIndexContext& context) override;
int local_sort_index_by_range(
const int64_t idx, const compaction::ObBuildIndexParam& param, const compaction::ObBuildIndexContext& context);
const int64_t idx, const compaction::ObBuildIndexParam& param, const compaction::ObBuildIndexContext& context) override;
int get_build_index_param(const uint64_t index_id, const int64_t schema_version, ObIPartitionReport* report,
compaction::ObBuildIndexParam& param) override;

Some files were not shown because too many files have changed in this diff Show More