Remove warning configurations

deps/oblib/src/CMakeLists.txt

@@ -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

src/clog/ob_clog_file_writer.h

@@ -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:

src/clog/ob_clog_mgr.h

@@ -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

src/clog/ob_file_id_cache.cpp

@@ -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) {

src/observer/mysql/obmp_base.h

@@ -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);
 

src/observer/ob_inner_sql_connection.h

@@ -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();
   }

src/observer/ob_inner_sql_connection_pool.h

@@ -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);
 

src/observer/ob_inner_sql_result.h

@@ -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 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 print_info() const override;
+
+  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_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_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 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;

src/observer/ob_service.h

@@ -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,

src/rootserver/backup/ob_backup_auto_delete_expired_backup.h

@@ -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:

src/rootserver/backup/ob_root_validate.h

@@ -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();
   }

src/rootserver/ob_backup_data_clean.h

@@ -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_;

src/rootserver/ob_create_inner_schema_executor.h

@@ -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:

src/rootserver/ob_daily_merge_scheduler.h

@@ -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.

src/rootserver/ob_empty_server_checker.h

@@ -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);
 

src/rootserver/ob_freeze_info_updater.h

@@ -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();

src/rootserver/ob_global_max_decided_trans_version_mgr.h

@@ -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();
   }

src/rootserver/ob_leader_coordinator.h

@@ -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,

src/rootserver/ob_major_freeze_launcher.h

@@ -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

src/rootserver/ob_partition_spliter.h

@@ -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();
   }

src/rootserver/ob_rebalance_task_mgr.h

@@ -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()

src/rootserver/ob_root_backup.h

@@ -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);

src/rootserver/ob_root_balancer.h

@@ -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();

src/rootserver/ob_root_inspection.h

@@ -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";
   };

src/rootserver/ob_rs_gts_monitor.h

@@ -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();

src/rootserver/ob_rs_gts_task_mgr.h

@@ -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;

src/rootserver/ob_schema_history_recycler.h

@@ -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();
   }

src/rootserver/ob_schema_revise_executor.h

@@ -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:

src/rootserver/ob_schema_spliter.h

@@ -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 {

src/rootserver/ob_upgrade_storage_format_version_executor.h

@@ -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:

src/rootserver/restore/ob_restore_scheduler.h

@@ -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);

src/share/cache/ob_kv_storecache.h

@@ -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
   {

src/share/partition_table/ob_partition_table_operator.h

@@ -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,

src/share/stat/ob_opt_stat_manager.h

@@ -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);

src/sql/engine/basic/ob_material.h

@@ -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;

src/sql/engine/dml/ob_multi_part_delete.h

@@ -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

src/sql/engine/dml/ob_multi_part_insert.h

@@ -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:

src/sql/engine/dml/ob_multi_part_update.h

@@ -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;

src/sql/engine/dml/ob_multi_table_insert_up.h

@@ -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,

src/sql/engine/dml/ob_multi_table_replace.h

@@ -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;
 

src/sql/engine/dml/ob_table_insert_all.h

@@ -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;

src/sql/engine/dml/ob_table_modify.h

@@ -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;

src/sql/engine/dml/ob_table_update.h

@@ -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;

src/sql/engine/expr/ob_expr_operator.h

@@ -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)
   {

src/sql/engine/pdml/ob_px_multi_part_modify.h

@@ -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;

src/sql/engine/px/ob_px_row_store.h

@@ -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;

src/sql/engine/sort/ob_in_memory_topn_sort.h

@@ -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;

src/sql/engine/sort/ob_local_merge_sort.h

@@ -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;

src/sql/engine/sort/ob_specific_columns_sort.h

@@ -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;

src/sql/engine/table/ob_table_scan.h

@@ -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;

src/sql/executor/ob_distributed_transmit.h

@@ -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;
   }

src/sql/executor/ob_transmit.h

@@ -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:

src/sql/ob_sql_partition_location_cache.h

@@ -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;
 

src/sql/optimizer/ob_join_order.h

@@ -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_);

src/sql/optimizer/ob_log_append.h

@@ -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;
   }

src/sql/optimizer/ob_log_conflict_row_fetcher.h

@@ -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_;

src/sql/optimizer/ob_log_count.h

@@ -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_;

src/sql/optimizer/ob_log_del_upd.h

@@ -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);
 

src/sql/optimizer/ob_log_delete.h

@@ -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);

src/sql/optimizer/ob_log_distinct.h

@@ -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;

src/sql/optimizer/ob_log_exchange.h

@@ -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(

src/sql/optimizer/ob_log_expr_values.h

@@ -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_;

src/sql/optimizer/ob_log_function_table.h

@@ -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_;

src/sql/optimizer/ob_log_granule_iterator.h

@@ -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;

src/sql/optimizer/ob_log_group_by.h

@@ -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,

src/sql/optimizer/ob_log_insert.h

@@ -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_;

src/sql/optimizer/ob_log_insert_all.h

@@ -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;
 

src/sql/optimizer/ob_log_join.h

@@ -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);

src/sql/optimizer/ob_log_limit.h

@@ -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;

src/sql/optimizer/ob_log_link.h

@@ -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;

src/sql/optimizer/ob_log_material.h

@@ -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);
   }

src/sql/optimizer/ob_log_merge.h

@@ -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);

src/sql/optimizer/ob_log_monitoring_dump.h

@@ -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)

src/sql/optimizer/ob_log_select_into.h

@@ -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_;

src/sql/optimizer/ob_log_sequence.h

@@ -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
   {

src/sql/optimizer/ob_log_set.h

@@ -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_;

src/sql/optimizer/ob_log_sort.h

@@ -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_;

src/sql/optimizer/ob_log_subplan_filter.h

@@ -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:

src/sql/optimizer/ob_log_subplan_scan.h

@@ -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_;

src/sql/optimizer/ob_log_table_lookup.h

@@ -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);
 

src/sql/optimizer/ob_log_table_scan.h

@@ -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);

src/sql/optimizer/ob_log_temp_table_access.h

@@ -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);

src/sql/optimizer/ob_log_temp_table_insert.h

@@ -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);
   }

src/sql/optimizer/ob_log_temp_table_transformation.h

@@ -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;
   }

src/sql/optimizer/ob_log_topk.h

@@ -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_;

src/sql/optimizer/ob_log_unpivot.h

@@ -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;

src/sql/optimizer/ob_log_update.h

@@ -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);
 

src/sql/optimizer/ob_log_values.h

@@ -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);

src/sql/optimizer/ob_log_window_function.h

@@ -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);

src/sql/resolver/dml/ob_del_upd_stmt.h

@@ -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);
   }

src/sql/resolver/dml/ob_insert_stmt.h

@@ -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);
 

src/sql/resolver/dml/ob_select_stmt.h

@@ -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);
   }

src/storage/blocksstable/ob_micro_block_row_scanner.h

@@ -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();

src/storage/compaction/ob_partition_merge.h

@@ -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:

src/storage/compaction/ob_partition_merge_builder.h

@@ -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:

src/storage/ob_long_ops_monitor.h

@@ -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_;
   }

src/storage/ob_old_sstable.h

@@ -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_;

src/storage/ob_partition_service.h

@@ -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);

src/storage/ob_partition_storage.h

@@ -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;