diff --git a/src/clog/ob_log_engine.h b/src/clog/ob_log_engine.h
index 1e966c67f2842bd5d96160f187e0416132bbcda8..43c14b600a5c6e7895f9ae0c7c8e49e4b1c6fedf 100644
--- a/src/clog/ob_log_engine.h
+++ b/src/clog/ob_log_engine.h
@@ -435,7 +435,7 @@ public:
   int broadcast_info(const common::ObMemberList& mem_list, const common::ObPartitionKey& key,
       const common::ObReplicaType& replica_type, const uint64_t max_confirmed_log_id) override;
   int send_restore_check_rqst(const common::ObAddr& server, const int64_t dst_cluster_id,
-      const common::ObPartitionKey& key, const ObRestoreCheckType restore_type);
+      const common::ObPartitionKey& key, const ObRestoreCheckType restore_type) override;
   // confirmed_info msg is special that no need compare proposal_id
   int submit_confirmed_info(const share::ObCascadMemberList& mem_list, const common::ObPartitionKey& key,
       const uint64_t log_id, const ObConfirmedInfo& confirmed_info, const bool batch_committed) override;
@@ -476,7 +476,7 @@ public:
   int get_remote_mc_ctx_array(
       const common::ObAddr& server, const common::ObPartitionArray& partition_array, McCtxArray& mc_ctx_array);
   int send_query_restore_end_id_resp(const common::ObAddr& server, const int64_t cluster_id,
-      const common::ObPartitionKey& partition_key, const uint64_t last_restore_log_id);
+      const common::ObPartitionKey& partition_key, const uint64_t last_restore_log_id) override;
   int update_min_using_file_id();
   uint32_t get_clog_min_using_file_id() const override;
   uint32_t get_clog_min_file_id() const override;
diff --git a/src/clog/ob_log_membership_mgr_V2.h b/src/clog/ob_log_membership_mgr_V2.h
index 24b417087f000e273b7e0af626886ed795ba5a8b..2a244b744189ad9aed6cd7cabf877b8674eb7384 100644
--- a/src/clog/ob_log_membership_mgr_V2.h
+++ b/src/clog/ob_log_membership_mgr_V2.h
@@ -115,7 +115,7 @@ public:
       const int64_t new_quorum, obrpc::ObMCLogInfo& log_info) override;
   virtual int64_t get_replica_num() const override;
   virtual common::ObReplicaType get_replica_type() const override;
-  virtual bool is_single_member_mode() const
+  virtual bool is_single_member_mode() const override
   {
     return (1 == replica_num_);
   }
diff --git a/src/clog/ob_log_sliding_window.h b/src/clog/ob_log_sliding_window.h
index 99da4dac67335322a851c377b311d6805c0b7846..d2fabde8cf248993d15b80a66bd7386d1e408496 100644
--- a/src/clog/ob_log_sliding_window.h
+++ b/src/clog/ob_log_sliding_window.h
@@ -542,7 +542,7 @@ private:
   int try_freeze_aggre_buffer_(const uint64_t log_id);
   int submit_freeze_aggre_buffer_task_(const uint64_t log_id);
   int submit_aggre_log_(ObAggreBuffer* buffer, const uint64_t log_id, const int64_t submit_timestamp);
-  int try_update_submit_timestamp(const int64_t base_ts);
+  int try_update_submit_timestamp(const int64_t base_ts) override;
   bool is_confirm_match_(const uint64_t log_id, const int64_t log_data_checksum, const int64_t log_epoch_id,
       const int64_t log_submit_timestamp, const int64_t confirmed_info_data_checksum,
       const int64_t confirmed_info_epoch_id, const int64_t confirmed_info_submit_timestamp);
diff --git a/src/clog/ob_partition_log_service.h b/src/clog/ob_partition_log_service.h
index bda3ae1cc168ffe5dac5bbc57263736877a723f3..7e80879b4c665e1727145502515eab995d90b5ab 100644
--- a/src/clog/ob_partition_log_service.h
+++ b/src/clog/ob_partition_log_service.h
@@ -555,7 +555,7 @@ public:
       const ObProposalID& ms_proposal_id) override;
   virtual int fake_receive_log(const ObAddr& server, const uint64_t log_id, const ObProposalID& proposal_id) override;
   virtual int process_restore_check_req(
-      const common::ObAddr& server, const int64_t cluster_id, const ObRestoreCheckType restore_type);
+      const common::ObAddr& server, const int64_t cluster_id, const ObRestoreCheckType restore_type) override;
   virtual int get_log(const common::ObAddr& server, const uint64_t log_id, const int64_t log_num,
       const ObFetchLogType fetch_type, const common::ObProposalID& proposal_id, const int64_t cluster_id,
       const common::ObReplicaType replica_type, const int64_t network_limit,
@@ -790,7 +790,7 @@ private:
   int response_sliding_window_info_(const common::ObAddr& server, const bool is_leader);
   int process_replica_type_change_();
   int process_reject_msg(
-      const common::ObAddr& server, const int64_t cluster_id, const int32_t msg_type, const int64_t timestamp);
+      const common::ObAddr& server, const int64_t cluster_id, const int32_t msg_type, const int64_t timestamp) override;
   int process_reregister_msg(
       const common::ObAddr& src_server, const share::ObCascadMember& new_leader, const int64_t send_ts) override;
   int process_restore_alive_msg(const common::ObAddr& server, const uint64_t start_log_id) override;
diff --git a/src/observer/mysql/obmp_query.h b/src/observer/mysql/obmp_query.h
index b86775486b3262d7b4f4dd36d81c39c891c54ecb..f6f19516a42e8938cd93506caa3bf22c31cd3334 100644
--- a/src/observer/mysql/obmp_query.h
+++ b/src/observer/mysql/obmp_query.h
@@ -45,14 +45,14 @@ public:
   virtual ~ObMPQuery();
 
 public:
-  virtual void disconnect();
-  virtual void update_last_pkt_pos()
+  virtual void disconnect() override;
+  virtual void update_last_pkt_pos() override
   {
     if (NULL != ez_buf_) {
       comp_context_.update_last_pkt_pos(ez_buf_->last);
     }
   }
-  virtual int response_packet(obmysql::ObMySQLPacket& pkt)
+  virtual int response_packet(obmysql::ObMySQLPacket& pkt) override
   {
     return ObMPBase::response_packet(pkt);
   }
@@ -60,19 +60,19 @@ public:
   {
     return ObMPBase::flush_buffer(is_last);
   }
-  virtual int send_error_packet(int err, const char* errmsg, bool is_partition_hit = true, void* extra_err_info = NULL)
+  virtual int send_error_packet(int err, const char* errmsg, bool is_partition_hit = true, void* extra_err_info = NULL) override
   {
     return ObMPBase::send_error_packet(err, errmsg, is_partition_hit, extra_err_info);
   }
-  virtual int send_ok_packet(sql::ObSQLSessionInfo& session, ObOKPParam& ok_param)
+  virtual int send_ok_packet(sql::ObSQLSessionInfo& session, ObOKPParam& ok_param) override
   {
     return ObMPBase::send_ok_packet(session, ok_param);
   }
-  virtual int send_eof_packet(const sql::ObSQLSessionInfo& session, const ObMySQLResultSet& result)
+  virtual int send_eof_packet(const sql::ObSQLSessionInfo& session, const ObMySQLResultSet& result) override
   {
     return ObMPBase::send_eof_packet(session, result);
   }
-  virtual bool need_send_extra_ok_packet()
+  virtual bool need_send_extra_ok_packet() override
   {
     return OB_NOT_NULL(get_conn()) && get_conn()->need_send_extra_ok_packet();
   }
@@ -103,11 +103,11 @@ public:
   }
 
 protected:
-  int process();
-  int deserialize();
+  int process() override;
+  int deserialize() override;
   int check_readonly_stmt(ObMySQLResultSet& result);
   int is_readonly_stmt(ObMySQLResultSet& result, bool& is_readonly);
-  virtual int after_process();
+  virtual int after_process() override;
 
 private:
   int register_callback_with_async(ObQueryExecCtx& query_ctx);
@@ -119,7 +119,7 @@ private:
   int process_single_stmt(const sql::ObMultiStmtItem& multi_stmt_item, sql::ObSQLSessionInfo& session,
       bool has_more_result, bool force_sync_resp, bool& async_resp_used, bool& need_disconnect);
 
-  virtual int before_response()
+  virtual int before_response() override
   {
     return OB_SUCCESS;
   }
diff --git a/src/observer/mysql/obmp_stmt_execute.h b/src/observer/mysql/obmp_stmt_execute.h
index 5778ff5b40e38c59c85816f57ad88e7b5e2615fe..42b321c37c49444e889d9014d80e206ab284cae1 100644
--- a/src/observer/mysql/obmp_stmt_execute.h
+++ b/src/observer/mysql/obmp_stmt_execute.h
@@ -73,42 +73,42 @@ public:
   }
 
 protected:
-  virtual int deserialize()
+  virtual int deserialize() override
   {
     return common::OB_SUCCESS;
   }
-  virtual int process();
-  virtual void disconnect()
+  virtual int process() override;
+  virtual void disconnect() override
   {
     ObMPBase::disconnect();
   }
-  virtual void update_last_pkt_pos()
+  virtual void update_last_pkt_pos() override
   {
     if (NULL != ez_buf_) {
       comp_context_.update_last_pkt_pos(ez_buf_->last);
     }
   }
-  virtual int send_error_packet(int err, const char* errmsg, bool is_partition_hit = true, void* extra_err_info = NULL)
+  virtual int send_error_packet(int err, const char* errmsg, bool is_partition_hit = true, void* extra_err_info = NULL) override
   {
     return ObMPBase::send_error_packet(err, errmsg, is_partition_hit, extra_err_info);
   }
-  virtual int send_ok_packet(sql::ObSQLSessionInfo& session, ObOKPParam& ok_param)
+  virtual int send_ok_packet(sql::ObSQLSessionInfo& session, ObOKPParam& ok_param) override
   {
     return ObMPBase::send_ok_packet(session, ok_param);
   }
-  virtual int send_eof_packet(const sql::ObSQLSessionInfo& session, const ObMySQLResultSet& result)
+  virtual int send_eof_packet(const sql::ObSQLSessionInfo& session, const ObMySQLResultSet& result) override
   {
     return ObMPBase::send_eof_packet(session, result);
   }
-  virtual bool need_send_extra_ok_packet()
+  virtual bool need_send_extra_ok_packet() override
   {
     return OB_NOT_NULL(get_conn()) && get_conn()->need_send_extra_ok_packet();
   }
-  virtual int response_packet(obmysql::ObMySQLPacket& pkt)
+  virtual int response_packet(obmysql::ObMySQLPacket& pkt) override
   {
     return ObMPBase::response_packet(pkt);
   }
-  virtual int after_process()
+  virtual int after_process() override
   {
     return ObMPBase::after_process();
   }
@@ -153,11 +153,11 @@ private:
       const common::ObTimeZoneInfo* tz_info, sql::TypeInfo* type_info, sql::TypeInfo* dst_type_info, ObObjParam& param);
   int decode_type_info(const char*& buf, sql::TypeInfo& type_info);
 
-  virtual int before_response()
+  virtual int before_response() override
   {
     return OB_SUCCESS;
   }
-  virtual int before_process();
+  virtual int before_process() override;
   void record_stat(const sql::stmt::StmtType type, const int64_t end_time) const;
 
   // copy or convert string, resove %extra_buf_len before result string.
diff --git a/src/observer/mysql/obmp_stmt_prepare.h b/src/observer/mysql/obmp_stmt_prepare.h
index 0f8495532cd4708dded565b16520f9992909759b..7007f49851f67ef0b062b2d736bbb74291b440ae 100644
--- a/src/observer/mysql/obmp_stmt_prepare.h
+++ b/src/observer/mysql/obmp_stmt_prepare.h
@@ -61,37 +61,37 @@ public:
   }
 
 protected:
-  virtual int deserialize();
+  virtual int deserialize() override;
   virtual int before_process() override;
-  virtual int process();
+  virtual int process() override;
 
-  virtual void disconnect()
+  virtual void disconnect() override
   {
     ObMPBase::disconnect();
   }
-  virtual void update_last_pkt_pos()
+  virtual void update_last_pkt_pos() override
   {
     if (NULL != ez_buf_) {
       comp_context_.update_last_pkt_pos(ez_buf_->last);
     }
   }
-  virtual int send_error_packet(int err, const char* errmsg, bool is_partition_hit = true, void* extra_err_info = NULL)
+  virtual int send_error_packet(int err, const char* errmsg, bool is_partition_hit = true, void* extra_err_info = NULL) override
   {
     return ObMPBase::send_error_packet(err, errmsg, is_partition_hit, extra_err_info);
   }
-  virtual int send_ok_packet(sql::ObSQLSessionInfo& session, ObOKPParam& ok_param)
+  virtual int send_ok_packet(sql::ObSQLSessionInfo& session, ObOKPParam& ok_param) override
   {
     return ObMPBase::send_ok_packet(session, ok_param);
   }
-  virtual int send_eof_packet(const sql::ObSQLSessionInfo& session, const ObMySQLResultSet& result)
+  virtual int send_eof_packet(const sql::ObSQLSessionInfo& session, const ObMySQLResultSet& result) override
   {
     return ObMPBase::send_eof_packet(session, result);
   }
-  virtual int response_packet(obmysql::ObMySQLPacket& pkt)
+  virtual int response_packet(obmysql::ObMySQLPacket& pkt) override
   {
     return ObMPBase::response_packet(pkt);
   }
-  virtual bool need_send_extra_ok_packet()
+  virtual bool need_send_extra_ok_packet() override
   {
     return OB_NOT_NULL(get_conn()) && get_conn()->need_send_extra_ok_packet();
   }
diff --git a/src/observer/ob_inner_sql_connection.cpp b/src/observer/ob_inner_sql_connection.cpp
index b750dc87d972f256821d3d1ff41b2508bd719024..21fb4367e1e375d4e74b5e8c870683049635adfa 100644
--- a/src/observer/ob_inner_sql_connection.cpp
+++ b/src/observer/ob_inner_sql_connection.cpp
@@ -58,7 +58,7 @@ public:
   virtual ~ObSqlQueryExecutor()
   {}
 
-  virtual int execute(sql::ObSql& engine, sql::ObSqlCtx& ctx, sql::ObResultSet& res)
+  virtual int execute(sql::ObSql& engine, sql::ObSqlCtx& ctx, sql::ObResultSet& res) override
   {
     observer::ObReqTimeGuard req_timeinfo_guard;
     int ret = OB_SUCCESS;
diff --git a/src/observer/virtual_table/ob_all_virtual_session_event.h b/src/observer/virtual_table/ob_all_virtual_session_event.h
index b7609a0a0992c3733c3c5694febf29b5fc9c071a..40ac5da4cd1e862a2fb080884293645a5b5af64a 100644
--- a/src/observer/virtual_table/ob_all_virtual_session_event.h
+++ b/src/observer/virtual_table/ob_all_virtual_session_event.h
@@ -80,7 +80,7 @@ public:
   }
 
 protected:
-  virtual int get_all_diag_info();
+  virtual int get_all_diag_info() override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObAllVirtualSessionEventI1);
diff --git a/src/observer/virtual_table/ob_all_virtual_session_stat.h b/src/observer/virtual_table/ob_all_virtual_session_stat.h
index 0ff017c9e13652d9e974bc9ba619ca71be37a2a0..67ae89f7fa71c0cbe73e9dd9808a96fa82993750 100644
--- a/src/observer/virtual_table/ob_all_virtual_session_stat.h
+++ b/src/observer/virtual_table/ob_all_virtual_session_stat.h
@@ -72,7 +72,7 @@ public:
   }
 
 protected:
-  virtual int get_all_diag_info();
+  virtual int get_all_diag_info() override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObAllVirtualSessionStatI1);
diff --git a/src/observer/virtual_table/ob_all_virtual_session_wait.h b/src/observer/virtual_table/ob_all_virtual_session_wait.h
index 05b4a11de0bcf990a72c0faf2d824c0ee78534ff..e716ec3dea35d511a1dd30b096607610292931f0 100644
--- a/src/observer/virtual_table/ob_all_virtual_session_wait.h
+++ b/src/observer/virtual_table/ob_all_virtual_session_wait.h
@@ -83,7 +83,7 @@ public:
   }
 
 protected:
-  virtual int get_all_diag_info();
+  virtual int get_all_diag_info() override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObAllVirtualSessionWaitI1);
diff --git a/src/observer/virtual_table/ob_all_virtual_session_wait_history.h b/src/observer/virtual_table/ob_all_virtual_session_wait_history.h
index 97705f2b542872308b359e11006f3e9fcd03f154..fe039451bc2984b8eb77c825d5e0ddd8b6b014e8 100644
--- a/src/observer/virtual_table/ob_all_virtual_session_wait_history.h
+++ b/src/observer/virtual_table/ob_all_virtual_session_wait_history.h
@@ -83,7 +83,7 @@ public:
   }
 
 protected:
-  virtual int get_all_diag_info();
+  virtual int get_all_diag_info() override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObAllVirtualSessionWaitHistoryI1);
diff --git a/src/observer/virtual_table/ob_all_virtual_sys_event.h b/src/observer/virtual_table/ob_all_virtual_sys_event.h
index 84a548c4efdbc9b02947654923953fdc3c00782b..0cc4d82ed5c5fae9df28cb9124a41068d8094ff8 100644
--- a/src/observer/virtual_table/ob_all_virtual_sys_event.h
+++ b/src/observer/virtual_table/ob_all_virtual_sys_event.h
@@ -76,7 +76,7 @@ public:
   }
 
 protected:
-  virtual int get_all_diag_info();
+  virtual int get_all_diag_info() override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObAllVirtualSysEventI1);
diff --git a/src/observer/virtual_table/ob_all_virtual_sys_stat.h b/src/observer/virtual_table/ob_all_virtual_sys_stat.h
index d555f3b9d8ae033a84b06fb1d518826da6a158d9..b0de6632068ca3bf45c77ab74cd619d195b2dc26 100644
--- a/src/observer/virtual_table/ob_all_virtual_sys_stat.h
+++ b/src/observer/virtual_table/ob_all_virtual_sys_stat.h
@@ -76,7 +76,7 @@ public:
   }
 
 protected:
-  virtual int get_all_diag_info();
+  virtual int get_all_diag_info() override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObAllVirtualSysStatI1);
diff --git a/src/observer/virtual_table/ob_iterate_virtual_table.h b/src/observer/virtual_table/ob_iterate_virtual_table.h
index de7419bc699a3470bd6922e1cb84744f5fd6eff1..c2b127455b2aad22053e52843a638d5211231dcb 100644
--- a/src/observer/virtual_table/ob_iterate_virtual_table.h
+++ b/src/observer/virtual_table/ob_iterate_virtual_table.h
@@ -37,7 +37,7 @@ public:
 private:
   virtual int init_non_exist_map_item(MapItem& item, const share::schema::ObColumnSchemaV2& col) override;
 
-  virtual int setup_inital_rowkey_condition(common::ObSqlString& cols, common::ObSqlString& vals);
+  virtual int setup_inital_rowkey_condition(common::ObSqlString& cols, common::ObSqlString& vals) override;
   virtual int add_extra_condition(common::ObSqlString& sql) override;
 
   bool check_tenant_in_range(const uint64_t tenant_id, const common::ObNewRange& range);
diff --git a/src/rootserver/ob_server_recovery_machine.h b/src/rootserver/ob_server_recovery_machine.h
index 4e0bc97de1d9706747e704a0ffc6ab40ac7bdbca..9472fbbef3f63c8d277b9091133fd2720244e369 100644
--- a/src/rootserver/ob_server_recovery_machine.h
+++ b/src/rootserver/ob_server_recovery_machine.h
@@ -274,7 +274,7 @@ public:
 
 public:
   virtual void run3() override;
-  virtual int blocking_run()
+  virtual int blocking_run() override
   {
     BLOCKING_RUN_IMPLEMENT();
   }
@@ -289,7 +289,7 @@ public:
   int on_check_pg_recovery_finished(const common::ObAddr& server, const int ret_code);
   int update_file_recovery_status(const common::ObAddr& server, const common::ObAddr& dest_server,
       const uint64_t tenant_id, const int64_t file_id, FileRecoveryStatus pre_status, FileRecoveryStatus cur_status);
-  void stop();
+  void stop() override;
 
 private:
   // Machine const
diff --git a/src/rootserver/ob_zone_unit_provider.h b/src/rootserver/ob_zone_unit_provider.h
index 255abc77766fa97100457900e37a4010a5f954ef..e511bb8d7bb0ae2dc0ea130f9a674f1ca6bbadab 100644
--- a/src/rootserver/ob_zone_unit_provider.h
+++ b/src/rootserver/ob_zone_unit_provider.h
@@ -65,8 +65,8 @@ public:
   {
     zu_ = my_zu;
   }
-  virtual const share::ObUnitInfo* at(int64_t idx) const;
-  virtual int64_t count() const;
+  virtual const share::ObUnitInfo* at(int64_t idx) const override;
+  virtual int64_t count() const override;
   virtual int get_target_unit_idx(const int64_t unit_offset, common::hash::ObHashSet<int64_t>& unit_set,
       const bool is_primary_partition, int64_t& unit_idx) const override;
   virtual int update_tg_pg_count(const int64_t unit_idx, const bool is_primary_partition) override;
@@ -141,8 +141,8 @@ public:
   {
     all_unit_ = all_unit;
   }
-  virtual const share::ObUnitInfo* at(int64_t idx) const;
-  virtual int64_t count() const;
+  virtual const share::ObUnitInfo* at(int64_t idx) const override;
+  virtual int64_t count() const override;
   virtual int get_target_unit_idx(const int64_t unit_offset, common::hash::ObHashSet<int64_t>& unit_set,
       const bool is_primary_partition, int64_t& unit_idx) const override;
   virtual int update_tg_pg_count(const int64_t unit_idx, const bool is_primary_partition) override;
@@ -161,7 +161,7 @@ public:
   {}
   virtual ~ObZoneLogonlyUnitProvider()
   {}
-  virtual int find_zone(const common::ObZone& zone, const ObZoneUnitAdaptor*& zua);
+  virtual int find_zone(const common::ObZone& zone, const ObZoneUnitAdaptor*& zua) override;
   virtual int get_all_zone_units(ZoneUnitArray& zone_unit) const override;
   virtual int get_all_ptr_zone_units(ZoneUnitPtrArray& zone_unit_ptr) const override;
   virtual bool exist(const ObZone& zone, const uint64_t unit_id) const override;
@@ -184,7 +184,7 @@ public:
   {}
   virtual int get_all_zone_units(ZoneUnitArray& zone_unit) const override;
   virtual int get_all_ptr_zone_units(ZoneUnitPtrArray& zone_unit_ptr) const override;
-  virtual int find_zone(const common::ObZone& zone, const ObZoneUnitAdaptor*& zua);
+  virtual int find_zone(const common::ObZone& zone, const ObZoneUnitAdaptor*& zua) override;
 
 private:
   const ZoneUnitArray& all_zone_units_;
@@ -201,7 +201,7 @@ public:
   {}
   virtual ~ObAllZoneUnitsProvider()
   {}
-  virtual int find_zone(const common::ObZone& zone, const ObZoneUnitAdaptor*& zua);
+  virtual int find_zone(const common::ObZone& zone, const ObZoneUnitAdaptor*& zua) override;
   virtual int get_all_zone_units(ZoneUnitArray& zone_unit) const override;
   virtual int get_all_ptr_zone_units(ZoneUnitPtrArray& zone_unit_ptr) const override;
 
diff --git a/src/share/partition_table/ob_partition_table_proxy.h b/src/share/partition_table/ob_partition_table_proxy.h
index 6feb8fe300a9e1de40def1cac21d3c51c4c801db..18f16df63285c3bb403b75ceb32b9b91690aeb73 100644
--- a/src/share/partition_table/ob_partition_table_proxy.h
+++ b/src/share/partition_table/ob_partition_table_proxy.h
@@ -156,7 +156,7 @@ public:
   {}
   virtual ~ObKVPartitionTableProxy()
   {}
-  virtual int reset()
+  virtual int reset() override
   {
     is_loaded_ = false;
     implicit_trans_started_ = false;
@@ -170,7 +170,7 @@ public:
 
   virtual int fetch_partition_info(const bool lock_replica, const uint64_t table_id, const int64_t partition_id,
       const bool filter_flag_replica, ObPartitionInfo& partition_info, const bool need_fetch_faillist = false,
-      const int64_t cluster_id = common::OB_INVALID_ID);
+      const int64_t cluster_id = common::OB_INVALID_ID) override;
 
   virtual int fetch_partition_infos(const uint64_t tenant_id, const uint64_t start_table_id,
       const int64_t start_partition_id, const bool filter_flag_replica, int64_t& max_fetch_count,
@@ -179,36 +179,36 @@ public:
 
   virtual int fetch_partition_infos_pt(const uint64_t pt_table_id, const int64_t pt_partition_id,
       const uint64_t start_table_id, const int64_t start_partition_id, int64_t& max_fetch_count,
-      common::ObIArray<ObPartitionInfo>& partition_infos, const bool need_fetch_faillist = false);
+      common::ObIArray<ObPartitionInfo>& partition_infos, const bool need_fetch_faillist = false) override;
 
   virtual int batch_fetch_partition_infos(const common::ObIArray<common::ObPartitionKey>& keys,
       common::ObIAllocator& allocator, common::ObArray<ObPartitionInfo*>& partitions,
       const int64_t cluster_id = common::OB_INVALID_ID) override;
 
-  virtual int update_replica(const ObPartitionReplica& replica, const bool replace);
-  virtual int update_replica(const ObPartitionReplica& replica);
+  virtual int update_replica(const ObPartitionReplica& replica, const bool replace) override;
+  virtual int update_replica(const ObPartitionReplica& replica) override;
   virtual int batch_report_with_optimization(
-      const common::ObIArray<ObPartitionReplica>& replicas, const bool with_role);
+      const common::ObIArray<ObPartitionReplica>& replicas, const bool with_role) override;
   virtual int batch_report_partition_role(
-      const common::ObIArray<share::ObPartitionReplica>& tasks, const common::ObRole new_role);
+      const common::ObIArray<share::ObPartitionReplica>& tasks, const common::ObRole new_role) override;
 
-  virtual int set_to_follower_role(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server);
+  virtual int set_to_follower_role(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server) override;
 
-  virtual int remove(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server);
+  virtual int remove(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server) override;
 
   virtual int set_unit_id(
-      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const uint64_t unit_id);
+      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const uint64_t unit_id) override;
 
-  virtual int set_original_leader(const uint64_t table_id, const int64_t partition_id, const bool is_original_leader);
+  virtual int set_original_leader(const uint64_t table_id, const int64_t partition_id, const bool is_original_leader) override;
 
   virtual int update_rebuild_flag(
-      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const bool rebuild);
+      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const bool rebuild) override;
 
   virtual int update_fail_list(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server,
-      const ObPartitionReplica::FailList& fail_list);
+      const ObPartitionReplica::FailList& fail_list) override;
 
   virtual int update_replica_status(
-      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const ObReplicaStatus status);
+      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const ObReplicaStatus status) override;
 
   static int fill_dml_splicer_for_update(const ObPartitionReplica& replica, ObDMLSqlSplicer& dml_splicer);
 
@@ -240,7 +240,7 @@ public:
 
   virtual int fetch_partition_info(const bool lock_replica, const uint64_t table_id, const int64_t partition_id,
       const bool filter_flag_replica, ObPartitionInfo& partition_info, const bool need_fetch_faillist = false,
-      const int64_t cluster_id = common::OB_INVALID_ID);
+      const int64_t cluster_id = common::OB_INVALID_ID) override;
 
   virtual int fetch_partition_infos(const uint64_t tenant_id, const uint64_t start_table_id,
       const int64_t start_partition_id, const bool filter_flag_replica, int64_t& max_fetch_count,
@@ -249,35 +249,35 @@ public:
 
   virtual int fetch_partition_infos_pt(const uint64_t pt_table_id, const int64_t pt_partition_id,
       const uint64_t start_table_id, const int64_t start_partition_id, int64_t& max_fetch_count,
-      common::ObIArray<ObPartitionInfo>& partition_infos, const bool need_fetch_faillist = false);
+      common::ObIArray<ObPartitionInfo>& partition_infos, const bool need_fetch_faillist = false) override;
 
   virtual int batch_fetch_partition_infos(const common::ObIArray<common::ObPartitionKey>& keys,
       common::ObIAllocator& allocator, common::ObArray<ObPartitionInfo*>& partitions,
       const int64_t cluster_id = common::OB_INVALID_ID) override;
 
-  virtual int update_replica(const ObPartitionReplica& replica, const bool replace);
-  virtual int update_replica(const ObPartitionReplica& replica);
+  virtual int update_replica(const ObPartitionReplica& replica, const bool replace) override;
+  virtual int update_replica(const ObPartitionReplica& replica) override;
   virtual int batch_report_with_optimization(
-      const common::ObIArray<ObPartitionReplica>& replicas, const bool with_role);
+      const common::ObIArray<ObPartitionReplica>& replicas, const bool with_role) override;
   virtual int batch_report_partition_role(
-      const common::ObIArray<share::ObPartitionReplica>& tasks, const common::ObRole new_role);
+      const common::ObIArray<share::ObPartitionReplica>& tasks, const common::ObRole new_role) override;
 
-  virtual int set_to_follower_role(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server);
+  virtual int set_to_follower_role(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server) override;
 
-  virtual int remove(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server);
+  virtual int remove(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server) override;
 
   virtual int set_unit_id(
-      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const uint64_t unit_id);
+      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const uint64_t unit_id) override;
 
   virtual int update_rebuild_flag(
-      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const bool rebuild);
+      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const bool rebuild) override;
 
-  virtual int set_original_leader(const uint64_t table_id, const int64_t partition_id, const bool is_original_leader);
+  virtual int set_original_leader(const uint64_t table_id, const int64_t partition_id, const bool is_original_leader) override;
   virtual int update_fail_list(const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server,
-      const ObPartitionReplica::FailList& fail_list);
+      const ObPartitionReplica::FailList& fail_list) override;
 
   virtual int update_replica_status(
-      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const ObReplicaStatus status);
+      const uint64_t table_id, const int64_t partition_id, const common::ObAddr& server, const ObReplicaStatus status) override;
 
   // batch update data_version of replicas which been creating right now.
   // Note: only support __all_tenant_meta_table partitions
diff --git a/src/sql/dtl/ob_dtl_basic_channel.h b/src/sql/dtl/ob_dtl_basic_channel.h
index 286d29bfc9808d3ad88b859f1826a63c780d315c..abd9ae5956ee272db32cdb744f43ca121048e681 100644
--- a/src/sql/dtl/ob_dtl_basic_channel.h
+++ b/src/sql/dtl/ob_dtl_basic_channel.h
@@ -343,7 +343,7 @@ public:
   explicit ObDtlBasicChannel(const uint64_t tenant_id, const uint64_t id, const common::ObAddr& peer);
   virtual ~ObDtlBasicChannel();
 
-  virtual DtlChannelType get_channel_type()
+  virtual DtlChannelType get_channel_type() override
   {
     return DtlChannelType::BASIC_CHANNEL;
   }
@@ -368,7 +368,7 @@ public:
   virtual int send(
       const ObDtlMsg& msg, int64_t timeout_ts, ObEvalCtx* eval_ctx = nullptr, bool is_eof = false) override;
   virtual int feedup(ObDtlLinkedBuffer*& buffer) override;
-  virtual int attach(ObDtlLinkedBuffer*& linked_buffer, bool is_first_buffer_cached = false);
+  virtual int attach(ObDtlLinkedBuffer*& linked_buffer, bool is_first_buffer_cached = false) override;
   // don't call send&flush in different threads.
   virtual int flush(bool wait = true, bool wait_response = true) override;
 
@@ -397,8 +397,8 @@ public:
   int unblock_on_decrease_size(int64_t size);
   bool belong_to_receive_data();
   bool belong_to_transmit_data();
-  virtual int clear_response_block();
-  virtual int wait_response();
+  virtual int clear_response_block() override;
+  virtual int wait_response() override;
   void inc_send_buffer_cnt()
   {
     ++send_buffer_cnt_;
@@ -425,12 +425,12 @@ public:
   }
 
   int get_processed_buffer(int64_t timeout);
-  virtual int clean_recv_list();
+  virtual int clean_recv_list() override;
   void clean_broadcast_buffer();
   bool has_less_buffer_cnt();
   int push_back_send_list(ObDtlLinkedBuffer* buffer);
 
-  void set_dfc_idx(int64_t idx)
+  void set_dfc_idx(int64_t idx) override
   {
     dfc_idx_ = idx;
   }
@@ -461,7 +461,7 @@ protected:
     return &msg_response_;
   }
 
-  OB_INLINE virtual bool has_msg()
+  OB_INLINE virtual bool has_msg() override
   {
     return recv_buffer_cnt_ > processed_buffer_cnt_;
   }
diff --git a/src/sql/dtl/ob_dtl_channel_loop.h b/src/sql/dtl/ob_dtl_channel_loop.h
index bde03ecc3404094805a9ae3827f238e90dbba2e3..16908e2c78d71ee8729e4da12d6cad5e6afd102d 100644
--- a/src/sql/dtl/ob_dtl_channel_loop.h
+++ b/src/sql/dtl/ob_dtl_channel_loop.h
@@ -109,7 +109,7 @@ private:
 
 public:
   int unblock_channels(int64_t data_channel_idx);
-  void add_last_data_list(ObDtlChannel* ch);
+  void add_last_data_list(ObDtlChannel* ch) override;
   virtual void remove_data_list(ObDtlChannel* ch, bool force) override;
   void add(ObDtlChannel* prev, ObDtlChannel* node, ObDtlChannel* next);
   virtual void set_first_no_data(ObDtlChannel* ch) override
diff --git a/src/sql/dtl/ob_dtl_local_channel.h b/src/sql/dtl/ob_dtl_local_channel.h
index 4a136a87d6f7aaef9487c3ab31d2506b1220942c..980547f98fc125c487be17650de1ea3f3bdfcc6f 100644
--- a/src/sql/dtl/ob_dtl_local_channel.h
+++ b/src/sql/dtl/ob_dtl_local_channel.h
@@ -37,7 +37,7 @@ public:
   explicit ObDtlLocalChannel(const uint64_t tenant_id, const uint64_t id, const common::ObAddr& peer);
   virtual ~ObDtlLocalChannel();
 
-  virtual DtlChannelType get_channel_type()
+  virtual DtlChannelType get_channel_type() override
   {
     return DtlChannelType::LOCAL_CHANNEL;
   }
@@ -46,7 +46,7 @@ public:
   virtual void destroy();
 
   virtual int feedup(ObDtlLinkedBuffer*& buffer) override;
-  virtual int send_message(ObDtlLinkedBuffer*& buf);
+  virtual int send_message(ObDtlLinkedBuffer*& buf) override;
 
 private:
   int send_shared_message(ObDtlLinkedBuffer*& buf);
diff --git a/src/sql/dtl/ob_dtl_rpc_channel.h b/src/sql/dtl/ob_dtl_rpc_channel.h
index d9483d4c197e65331dd2e2b4f006b662371252f9..523349f15cadd042f011bd3d605c056ce13f20af 100644
--- a/src/sql/dtl/ob_dtl_rpc_channel.h
+++ b/src/sql/dtl/ob_dtl_rpc_channel.h
@@ -92,7 +92,7 @@ public:
   explicit ObDtlRpcChannel(const uint64_t tenant_id, const uint64_t id, const common::ObAddr& peer);
   virtual ~ObDtlRpcChannel();
 
-  virtual DtlChannelType get_channel_type()
+  virtual DtlChannelType get_channel_type() override
   {
     return DtlChannelType::RPC_CHANNEL;
   }
@@ -101,7 +101,7 @@ public:
   virtual void destroy();
 
   virtual int feedup(ObDtlLinkedBuffer*& buffer) override;
-  virtual int send_message(ObDtlLinkedBuffer*& buf);
+  virtual int send_message(ObDtlLinkedBuffer*& buf) override;
 };
 
 }  // namespace dtl
diff --git a/src/sql/engine/aggregate/ob_groupby_op.h b/src/sql/engine/aggregate/ob_groupby_op.h
index a648a4c2fa093d97b76c41c73de5293a57c9a51f..822f5f87987b0761f554e718142a7fdb61b1af6c 100644
--- a/src/sql/engine/aggregate/ob_groupby_op.h
+++ b/src/sql/engine/aggregate/ob_groupby_op.h
@@ -53,7 +53,7 @@ public:
   }
 
   virtual int inner_open() override;
-  virtual int inner_get_next_row() = 0;
+  virtual int inner_get_next_row() override = 0;
   virtual int rescan() override;
   virtual int switch_iterator() override;
   virtual int inner_close() override;
diff --git a/src/sql/engine/connect_by/ob_nested_loop_connect_by.h b/src/sql/engine/connect_by/ob_nested_loop_connect_by.h
index 68069d9ef02c94b12c03a0a010d8414777e12819..3950daf590b53ff64e66794a4142dca357753216 100644
--- a/src/sql/engine/connect_by/ob_nested_loop_connect_by.h
+++ b/src/sql/engine/connect_by/ob_nested_loop_connect_by.h
@@ -134,7 +134,7 @@ public:
     virtual ~ObConnectByCtx()
     {}
     void reset();
-    virtual void destroy()
+    virtual void destroy() override
     {
       connect_by_pump_.~ObConnectByPump();  // must be call
       ObConnectByBaseCtx::destroy();
diff --git a/src/sql/engine/dml/ob_table_modify_op.h b/src/sql/engine/dml/ob_table_modify_op.h
index 3819c65308203b63027d3e2691c659ccaa975ee5..630027ca5112fd5356c391da54506be9b7d31951 100644
--- a/src/sql/engine/dml/ob_table_modify_op.h
+++ b/src/sql/engine/dml/ob_table_modify_op.h
@@ -169,7 +169,7 @@ public:
   {}
   virtual ~ObTableModifyOpInput()
   {}
-  virtual void reset()
+  virtual void reset() override
   {
     location_idx_ = common::OB_INVALID_INDEX;
     part_infos_.reset();
@@ -187,7 +187,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);
   }
@@ -351,9 +351,9 @@ public:
   }
 
 protected:
-  OperatorOpenOrder get_operator_open_order() const;
-  virtual int inner_open();
-  virtual int inner_close();
+  OperatorOpenOrder get_operator_open_order() const override;
+  virtual int inner_open() override;
+  virtual int inner_close() override;
 
   // project expressions to old style row, allocate cells from ctx_.get_allocator() if needed.
   int project_row(ObExpr* const* exprs, const int64_t cnt, common::ObNewRow& row) const;
diff --git a/src/sql/engine/expr/ob_expr_calc_partition_id.h b/src/sql/engine/expr/ob_expr_calc_partition_id.h
index ba1cc9541abe6378252b99ead1c5d0f130537de7..f5e5258fb07020d0fe54c8901f16a0d25088ce2e 100644
--- a/src/sql/engine/expr/ob_expr_calc_partition_id.h
+++ b/src/sql/engine/expr/ob_expr_calc_partition_id.h
@@ -60,7 +60,7 @@ public:
   explicit ObExprCalcPartitionId(common::ObIAllocator& alloc);
   virtual ~ObExprCalcPartitionId();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_no_partition_location(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
   static int calc_partition_level_one(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
diff --git a/src/sql/engine/expr/ob_expr_calc_urowid.h b/src/sql/engine/expr/ob_expr_calc_urowid.h
index cf168f35850741aebb92b97b715c2c1e5c06b223..93a58d50761eff6715dfac69fe1c20dfa7350aac 100644
--- a/src/sql/engine/expr/ob_expr_calc_urowid.h
+++ b/src/sql/engine/expr/ob_expr_calc_urowid.h
@@ -22,11 +22,11 @@ public:
   explicit ObExprCalcURowID(common::ObIAllocator& alloc);
   virtual ~ObExprCalcURowID();
 
-  virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_statck, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_typeN(ObExprResType& type, ObExprResType* types_statck, int64_t param_num,
+      common::ObExprTypeCtx& type_ctx) const override;
 
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* obj_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* obj_stack, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_concat.h b/src/sql/engine/expr/ob_expr_concat.h
index f81720e90aeae7f459314b73d59a7ff68d7730da..f622ac4f2b87fa658660217f759b575af1301c1a 100644
--- a/src/sql/engine/expr/ob_expr_concat.h
+++ b/src/sql/engine/expr/ob_expr_concat.h
@@ -23,9 +23,9 @@ public:
   virtual ~ObExprConcat();
 
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
       common::ObIAllocator* allocator, const common::ObObjType result_type, bool is_oracle_mode);
   // Check result length with %max_result_len (if %max_result_len greater than zero)
diff --git a/src/sql/engine/expr/ob_expr_concat_ws.h b/src/sql/engine/expr/ob_expr_concat_ws.h
index 9c623d91f8b9ba58d2985c1fca237987a0ca59ca..d9f8811ceb456d34aeb7f63f505f428821587885 100644
--- a/src/sql/engine/expr/ob_expr_concat_ws.h
+++ b/src/sql/engine/expr/ob_expr_concat_ws.h
@@ -22,9 +22,9 @@ public:
   explicit ObExprConcatWs(common::ObIAllocator& alloc);
   virtual ~ObExprConcatWs();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   // connect two strings by separator
   static int concat_ws(
       const common::ObString obj1, const common::ObString obj2, const int64_t buf_len, char** string_buf, int64_t& pos);
diff --git a/src/sql/engine/expr/ob_expr_div.h b/src/sql/engine/expr/ob_expr_div.h
index 0666323881a1422b94f5eaf1a4a0f4411fcf3396..43ef13612cf7e4851e68cab9dae1e3eda440edf3 100644
--- a/src/sql/engine/expr/ob_expr_div.h
+++ b/src/sql/engine/expr/ob_expr_div.h
@@ -24,9 +24,9 @@ public:
   virtual ~ObExprDiv()
   {}
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& res, const common::ObObj& obj1, const common::ObObj& obj2,
       common::ObIAllocator* allocator, common::ObScale calc_scale);
   static int calc_for_avg(common::ObObj& res, const common::ObObj& obj1, const common::ObObj& obj2,
diff --git a/src/sql/engine/expr/ob_expr_format.h b/src/sql/engine/expr/ob_expr_format.h
index 7cad29e5afd096cd28be8d76781744988fae7a0e..94f5c26626f382a40207f834014bcdeda8291f67 100644
--- a/src/sql/engine/expr/ob_expr_format.h
+++ b/src/sql/engine/expr/ob_expr_format.h
@@ -38,9 +38,9 @@ public:
   explicit ObExprFormat(common::ObIAllocator& alloc);
   virtual ~ObExprFormat();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_format_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_greater_equal.h b/src/sql/engine/expr/ob_expr_greater_equal.h
index b899909561d4a4dc087f9bbfa5ab84b0a5a25916..b562d63c9c70085fd5d12fd05ddada4c5dcb1644 100644
--- a/src/sql/engine/expr/ob_expr_greater_equal.h
+++ b/src/sql/engine/expr/ob_expr_greater_equal.h
@@ -22,10 +22,10 @@ public:
   ObExprGreaterEqual();
   explicit ObExprGreaterEqual(common::ObIAllocator& alloc);
   virtual ~ObExprGreaterEqual(){};
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override
   {
diff --git a/src/sql/engine/expr/ob_expr_greater_than.h b/src/sql/engine/expr/ob_expr_greater_than.h
index 69cc50acd71eae7f80d293d64e54d966c5dc8042..c1b56bb58f648b120503252ddb4556d689c22807 100644
--- a/src/sql/engine/expr/ob_expr_greater_than.h
+++ b/src/sql/engine/expr/ob_expr_greater_than.h
@@ -24,10 +24,10 @@ public:
   ObExprGreaterThan();
   explicit ObExprGreaterThan(common::ObIAllocator& alloc);
   virtual ~ObExprGreaterThan(){};
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override
   {
diff --git a/src/sql/engine/expr/ob_expr_hex.h b/src/sql/engine/expr/ob_expr_hex.h
index b3c011caa85565810f7de6ff9278fa41821811a8..8356e5cfba9b8cf222106b3014637614994d478c 100644
--- a/src/sql/engine/expr/ob_expr_hex.h
+++ b/src/sql/engine/expr/ob_expr_hex.h
@@ -21,9 +21,9 @@ class ObExprHex : public ObStringExprOperator {
 public:
   explicit ObExprHex(common::ObIAllocator& alloc);
   virtual ~ObExprHex();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& text, common::ObCastCtx& cast_ctx);
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_initcap.h b/src/sql/engine/expr/ob_expr_initcap.h
index ff2ecda0e9b6a585fced3e029611f3f77297ce59..f2c02630a900203db3acd542b82912640c152251 100644
--- a/src/sql/engine/expr/ob_expr_initcap.h
+++ b/src/sql/engine/expr/ob_expr_initcap.h
@@ -22,8 +22,10 @@ class ObExprInitcap : public ObStringExprOperator {
 public:
   explicit ObExprInitcap(common::ObIAllocator& alloc);
   virtual ~ObExprInitcap();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text_obj, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(
+      ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(
+      common::ObObj& result, const common::ObObj& text_obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int initcap_string(const common::ObString& text, const common::ObCollationType cs_type,
       common::ObIAllocator* allocator, common::ObString& res_str);
diff --git a/src/sql/engine/expr/ob_expr_int2ip.h b/src/sql/engine/expr/ob_expr_int2ip.h
index 111bc3fe4a739676b57ed288b543b277864bcf60..545e046e0ab9a427bf7c636dbc2b2625f4328eab 100644
--- a/src/sql/engine/expr/ob_expr_int2ip.h
+++ b/src/sql/engine/expr/ob_expr_int2ip.h
@@ -21,9 +21,9 @@ class ObExprInt2ip : public ObStringExprOperator {
 public:
   explicit ObExprInt2ip(common::ObIAllocator& alloc);
   virtual ~ObExprInt2ip();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& text, common::ObExprStringBuf& string_buf);
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int int2ip_varchar(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_int_div.h b/src/sql/engine/expr/ob_expr_int_div.h
index f41496b306f4eac17039ed94a7fae97cd985ba96..bfda8d66ac1cc35811b02e5a05fc8e8e30f8d3ec 100644
--- a/src/sql/engine/expr/ob_expr_int_div.h
+++ b/src/sql/engine/expr/ob_expr_int_div.h
@@ -21,9 +21,9 @@ public:
   explicit ObExprIntDiv(common::ObIAllocator& alloc);
   virtual ~ObExprIntDiv(){};
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result2(
-      common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2,
       common::ObIAllocator* allocator, common::ObScale scale);
   static int div_int_int(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_interval.h b/src/sql/engine/expr/ob_expr_interval.h
index 270c13c8bc8a717b1535ae267ee9ac589af63959..6a9a99c760aceace36c2d2515a1c45d30a51d082 100644
--- a/src/sql/engine/expr/ob_expr_interval.h
+++ b/src/sql/engine/expr/ob_expr_interval.h
@@ -30,7 +30,7 @@ public:
   virtual ~ObExprInterval()
   {}
 
-  virtual int assign(const ObExprOperator& other);
+  virtual int assign(const ObExprOperator& other) override;
 
   OB_INLINE void set_use_binary_search(bool use_binary_search)
   {
diff --git a/src/sql/engine/expr/ob_expr_ip2int.h b/src/sql/engine/expr/ob_expr_ip2int.h
index 26f1b33c9c077d61eba68db794c52b81ec197ece..1da2b92c3eefcdbcfacc6ca91ec374f1f39926e5 100644
--- a/src/sql/engine/expr/ob_expr_ip2int.h
+++ b/src/sql/engine/expr/ob_expr_ip2int.h
@@ -21,9 +21,9 @@ class ObExprIp2int : public ObFuncExprOperator {
 public:
   explicit ObExprIp2int(common::ObIAllocator& alloc);
   virtual ~ObExprIp2int();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx);
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int ip2int_varchar(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_is.h b/src/sql/engine/expr/ob_expr_is.h
index bde4e24e106ae7c719758110f97d32f0bbfb8f8c..516e3d3b27a2d3afb2cc5d369143dab04ee245f5 100644
--- a/src/sql/engine/expr/ob_expr_is.h
+++ b/src/sql/engine/expr/ob_expr_is.h
@@ -59,9 +59,9 @@ public:
   virtual ~ObExprIs(){};
 
   virtual int calc_with_null(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
-      const common::ObObj& obj3, common::ObCastCtx& cast_ctx) const;
+      const common::ObObj& obj3, common::ObCastCtx& cast_ctx) const override;
   virtual int calc_with_int(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObCastCtx& cast_ctx) const;
+      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObCastCtx& cast_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_is_date_int_null(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   static int calc_is_null(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
@@ -89,9 +89,9 @@ public:
   virtual ~ObExprIsNot(){};
 
   virtual int calc_with_null(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
-      const common::ObObj& obj3, common::ObCastCtx& cast_ctx) const;
+      const common::ObObj& obj3, common::ObCastCtx& cast_ctx) const override;
   virtual int calc_with_int(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObCastCtx& cast_ctx) const;
+      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObCastCtx& cast_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_is_not_null(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   static int int_is_not_true(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_is_serving_tenant.h b/src/sql/engine/expr/ob_expr_is_serving_tenant.h
index 8df4692e1ed546f3f66c318b54a4fdf77f881f4e..9396b1afca765076f48ded4263db6f7caff942d3 100644
--- a/src/sql/engine/expr/ob_expr_is_serving_tenant.h
+++ b/src/sql/engine/expr/ob_expr_is_serving_tenant.h
@@ -23,9 +23,9 @@ public:
   virtual ~ObExprIsServingTenant();
 
   virtual int calc_result_type3(ObExprResType& type, ObExprResType& type1, ObExprResType& type2, ObExprResType& type3,
-      common::ObExprTypeCtx& type_ctx) const;
+      common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result3(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
-      const common::ObObj& obj3, common::ObExprCtx& expr_ctx) const;
+      const common::ObObj& obj3, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
   static int eval_is_serving_tenant(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_last_exec_id.h b/src/sql/engine/expr/ob_expr_last_exec_id.h
index ab651a2606b94f84e1e8ec125d1a4845cb66da42..735717cc7105fa4358d8008a8d0f227989f5079b 100644
--- a/src/sql/engine/expr/ob_expr_last_exec_id.h
+++ b/src/sql/engine/expr/ob_expr_last_exec_id.h
@@ -19,8 +19,8 @@ class ObExprLastExecId : public ObStringExprOperator {
 public:
   explicit ObExprLastExecId(common::ObIAllocator& alloc);
   virtual ~ObExprLastExecId();
-  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const override;
   static int eval_last_exec_id(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_last_insert_id.h b/src/sql/engine/expr/ob_expr_last_insert_id.h
index daa9ceeb0199dd476978dd04ce4462c727907fae..086b447a5a2d5b0f937709bebd018c66cd0aa2de 100644
--- a/src/sql/engine/expr/ob_expr_last_insert_id.h
+++ b/src/sql/engine/expr/ob_expr_last_insert_id.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprLastInsertID(common::ObIAllocator& alloc);
   virtual ~ObExprLastInsertID();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_last_trace_id.h b/src/sql/engine/expr/ob_expr_last_trace_id.h
index 6f19090dcdd907e5bc5c06ca62d652ff32325be7..7aeb95c91efc000355c1caa6246743b9958e0bb1 100644
--- a/src/sql/engine/expr/ob_expr_last_trace_id.h
+++ b/src/sql/engine/expr/ob_expr_last_trace_id.h
@@ -21,8 +21,8 @@ class ObExprLastTraceId : public ObStringExprOperator {
 public:
   explicit ObExprLastTraceId(common::ObIAllocator& alloc);
   virtual ~ObExprLastTraceId();
-  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const override;
   static int eval_last_trace_id(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_least.h b/src/sql/engine/expr/ob_expr_least.h
index 6f59590edc27ea3556cd1e990dc20cc9d5fb5a5c..801330db961518be010da9ef89b9142a3cbc9d90 100644
--- a/src/sql/engine/expr/ob_expr_least.h
+++ b/src/sql/engine/expr/ob_expr_least.h
@@ -40,9 +40,9 @@ public:
       const char* name = N_LEAST);
   virtual ~ObExprBaseLeast();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_stack, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types_stack, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num,
       const ObExprResType& expected_type, common::ObExprCtx& expr_ctx);
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
diff --git a/src/sql/engine/expr/ob_expr_length.h b/src/sql/engine/expr/ob_expr_length.h
index e35d5bf7bb75dd4e713cad7ba1376d0ce4bd526d..cf1e19e9ccb27f1a8a1c926ef91807917b93d63e 100644
--- a/src/sql/engine/expr/ob_expr_length.h
+++ b/src/sql/engine/expr/ob_expr_length.h
@@ -21,9 +21,9 @@ class ObExprLength : public ObFuncExprOperator {
 public:
   explicit ObExprLength(common::ObIAllocator& alloc);
   virtual ~ObExprLength();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx);
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_null(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   static int calc_oracle_mode(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_lengthb.h b/src/sql/engine/expr/ob_expr_lengthb.h
index b8e87ea13901e8f3ff2b10d6729cd1bb6ff5be55..d3610886125ce34a0029936f1d45ab368cc86277 100644
--- a/src/sql/engine/expr/ob_expr_lengthb.h
+++ b/src/sql/engine/expr/ob_expr_lengthb.h
@@ -24,9 +24,9 @@ class ObExprLengthb : public ObFuncExprOperator {
 public:
   explicit ObExprLengthb(common::ObIAllocator& alloc);
   virtual ~ObExprLengthb();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx);
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_lengthb_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_less_equal.h b/src/sql/engine/expr/ob_expr_less_equal.h
index 0c349fc800ac68d6ec3f4fa504785b90cfdce4cf..0b63bfe179195f3a47da4036e48d89b91ff3b0f3 100644
--- a/src/sql/engine/expr/ob_expr_less_equal.h
+++ b/src/sql/engine/expr/ob_expr_less_equal.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprLessEqual(common::ObIAllocator& alloc);
   virtual ~ObExprLessEqual(){};
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
       const common::ObCompareCtx& cmp_ctx, common::ObCastCtx& cast_ctx);
   static int calc_nocast(
diff --git a/src/sql/engine/expr/ob_expr_less_than.h b/src/sql/engine/expr/ob_expr_less_than.h
index 5d270d04b3d5d9311dee0f1ff0bf2cd582b68e68..de5591108aa43eb2fce4fe9909c582740f689095 100644
--- a/src/sql/engine/expr/ob_expr_less_than.h
+++ b/src/sql/engine/expr/ob_expr_less_than.h
@@ -25,9 +25,9 @@ public:
   explicit ObExprLessThan(common::ObIAllocator& alloc);
   virtual ~ObExprLessThan(){};
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
       const common::ObCompareCtx& cmp_ctx, common::ObCastCtx& cast_ctx);
   static int calc_nocast(
diff --git a/src/sql/engine/expr/ob_expr_like.h b/src/sql/engine/expr/ob_expr_like.h
index 91d7a5a99bb53ffb08689a5677dc6fb9aa4cf8ea..72e6f26fe97347a034fbf218050cf963c9ea64ee 100644
--- a/src/sql/engine/expr/ob_expr_like.h
+++ b/src/sql/engine/expr/ob_expr_like.h
@@ -95,9 +95,9 @@ public:
   explicit ObExprLike(common::ObIAllocator& alloc);
   virtual ~ObExprLike();
   virtual int calc_result_type3(ObExprResType& type, ObExprResType& type1, ObExprResType& type2, ObExprResType& type3,
-      common::ObExprTypeCtx& type_ctx) const;
+      common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result3(common::ObObj& result, const common::ObObj& obj, const common::ObObj& pattern,
-      const common::ObObj& escape, common::ObExprCtx& expr_ctx) const;
+      const common::ObObj& escape, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& result, common::ObCollationType coll_type, const common::ObObj& obj,
       const common::ObObj& pattern, const common::ObObj& escape, common::ObExprCtx& expr_ctx,
       const bool is_going_optimization, const uint64_t like_id, const bool check_optimization);
@@ -105,7 +105,7 @@ public:
   static int calc_with_non_instr_mode(T& result, const common::ObCollationType coll_type,
       const common::ObCollationType escape_coll, const common::ObString& text_val, const common::ObString& pattern_val,
       const common::ObString& escape_val);
-  int assign(const ObExprOperator& other);
+  int assign(const ObExprOperator& other) override;
   OB_INLINE bool is_pattern_literal() const
   {
     return is_pattern_literal_;
diff --git a/src/sql/engine/expr/ob_expr_lnnvl.h b/src/sql/engine/expr/ob_expr_lnnvl.h
index 2794ad3a883e73f9c38863cf608a2b9d84ad0636..df4d0f46f9e704ad46893d6ab650c9e9d58e4e13 100644
--- a/src/sql/engine/expr/ob_expr_lnnvl.h
+++ b/src/sql/engine/expr/ob_expr_lnnvl.h
@@ -21,8 +21,8 @@ class ObExprFuncLnnvl : public ObFuncExprOperator {
 public:
   explicit ObExprFuncLnnvl(common::ObIAllocator& alloc);
   virtual ~ObExprFuncLnnvl();
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& input, common::ObExprCtx& expr_ctx) const;
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& input, common::ObExprCtx& expr_ctx) const override;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
   static int eval_lnnvl(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_log10.h b/src/sql/engine/expr/ob_expr_log10.h
index a7a70f2f57fb2d18a0f4f02e63d741364fe1a6b3..8377d0e6aee878b3171ec16bca14e3f6ab8a0c64 100644
--- a/src/sql/engine/expr/ob_expr_log10.h
+++ b/src/sql/engine/expr/ob_expr_log10.h
@@ -21,8 +21,8 @@ class ObExprLog10 : public ObFuncExprOperator {
 public:
   explicit ObExprLog10(common::ObIAllocator& alloc);
   virtual ~ObExprLog10();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_log2.h b/src/sql/engine/expr/ob_expr_log2.h
index 83080e23ec400160b970c275752f2f24a24e0daf..cad0962ec9fca33e41d9ff9ce3985d306c04fbf8 100644
--- a/src/sql/engine/expr/ob_expr_log2.h
+++ b/src/sql/engine/expr/ob_expr_log2.h
@@ -21,8 +21,8 @@ class ObExprLog2 : public ObFuncExprOperator {
 public:
   explicit ObExprLog2(common::ObIAllocator& alloc);
   virtual ~ObExprLog2();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_lower.h b/src/sql/engine/expr/ob_expr_lower.h
index 27931230cb6a01289029e54a0c5caa5f96e2c93c..9536a987d3cdc1495c4f406e531420a9ae8eff33 100644
--- a/src/sql/engine/expr/ob_expr_lower.h
+++ b/src/sql/engine/expr/ob_expr_lower.h
@@ -55,8 +55,8 @@ public:
   virtual ~ObExprLower()
   {}
   virtual int calc(const common::ObCollationType cs_type, char* src, int32_t src_len, char* dest, int32_t det_len,
-      int32_t& out_len) const;
-  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const;
+      int32_t& out_len) const override;
+  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_lower(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
@@ -70,8 +70,8 @@ public:
   virtual ~ObExprUpper()
   {}
   virtual int calc(const common::ObCollationType cs_type, char* src, int32_t src_len, char* dest, int32_t det_len,
-      int32_t& out_len) const;
-  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const;
+      int32_t& out_len) const override;
+  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_upper(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
@@ -85,8 +85,8 @@ public:
   virtual ~ObExprNlsLower()
   {}
   virtual int calc(const common::ObCollationType cs_type, char* src, int32_t src_len, char* dest, int32_t det_len,
-      int32_t& out_len) const;
-  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const;
+      int32_t& out_len) const override;
+  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_lower(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
@@ -100,8 +100,8 @@ public:
   virtual ~ObExprNlsUpper()
   {}
   virtual int calc(const common::ObCollationType cs_type, char* src, int32_t src_len, char* dest, int32_t det_len,
-      int32_t& out_len) const;
-  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const;
+      int32_t& out_len) const override;
+  virtual int32_t get_case_mutiply(const common::ObCollationType cs_type) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_upper(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_lrpad.h b/src/sql/engine/expr/ob_expr_lrpad.h
index f0578e7466ea57dfa29439799f82029a3437edd2..fae48691ba4974635cb5c7a2d032d142c424dca5 100644
--- a/src/sql/engine/expr/ob_expr_lrpad.h
+++ b/src/sql/engine/expr/ob_expr_lrpad.h
@@ -100,7 +100,7 @@ public:
   virtual int calc_result3(common::ObObj& result, const common::ObObj& text, const common::ObObj& len,
       const common::ObObj& pad_text, common::ObExprCtx& expr_ctx) const override;
   // for engine 3.0
-  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const;
+  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_mysql_rpad_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res);
 
 private:
@@ -118,7 +118,7 @@ public:
   virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
       common::ObExprCtx& expr_ctx) const override;
   // for engine 3.0
-  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const;
+  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_oracle_lpad_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res);
 
 private:
@@ -136,7 +136,7 @@ public:
   virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
       common::ObExprCtx& expr_ctx) const override;
   // for engine 3.0
-  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const;
+  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_oracle_rpad_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res);
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_md5.h b/src/sql/engine/expr/ob_expr_md5.h
index 3c78ceee27d9276e5554a6323b8213916f3d045a..64106cbc4526c53681c98a3567a8c8b4dbfe85c0 100644
--- a/src/sql/engine/expr/ob_expr_md5.h
+++ b/src/sql/engine/expr/ob_expr_md5.h
@@ -24,8 +24,8 @@ public:
   virtual ~ObExprMd5();
 
 public:
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& str, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& str_obj, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& str, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& str_obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_md5(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_minus.h b/src/sql/engine/expr/ob_expr_minus.h
index 9a35f36e4db8861b0efbc6c9bfad81775701c90d..aab38a10d659a0dae864863d315ebfed19407173 100644
--- a/src/sql/engine/expr/ob_expr_minus.h
+++ b/src/sql/engine/expr/ob_expr_minus.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprMinus(common::ObIAllocator& alloc, ObExprOperatorType type = T_OP_MINUS);
   virtual ~ObExprMinus(){};
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2,
       common::ObIAllocator* allocator, common::ObScale scale);
   static int calc(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx,
diff --git a/src/sql/engine/expr/ob_expr_mod.h b/src/sql/engine/expr/ob_expr_mod.h
index a6fc291e5929e41186e7b0fe87494cd405ae00eb..aca0f919ea95b8c1a9d7c58e8024cbf33235f4f3 100644
--- a/src/sql/engine/expr/ob_expr_mod.h
+++ b/src/sql/engine/expr/ob_expr_mod.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprMod(common::ObIAllocator& alloc);
   virtual ~ObExprMod(){};
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result2(
-      common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result2(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2,
       common::ObIAllocator* allocator, common::ObScale scale);
 
diff --git a/src/sql/engine/expr/ob_expr_mul.h b/src/sql/engine/expr/ob_expr_mul.h
index 5d13b4538f84b36db86ace6765599e875f61d04d..2ebc306ffbb7e45d5918b1196dc2374cab73e720 100644
--- a/src/sql/engine/expr/ob_expr_mul.h
+++ b/src/sql/engine/expr/ob_expr_mul.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprMul(common::ObIAllocator& alloc, ObExprOperatorType type = T_OP_MUL);
   virtual ~ObExprMul(){};
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& left, const common::ObObj& right,
+      common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2,
       common::ObIAllocator* allocator, common::ObScale scale);
   static int calc(common::ObObj& res, const common::ObObj& ojb1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx,
diff --git a/src/sql/engine/expr/ob_expr_not_equal.h b/src/sql/engine/expr/ob_expr_not_equal.h
index b9bb45d13d44856233b10ad68b6b355763632034..4fb25c13f6d989501ad639a70e1db2eaaea6f9dd 100644
--- a/src/sql/engine/expr/ob_expr_not_equal.h
+++ b/src/sql/engine/expr/ob_expr_not_equal.h
@@ -24,15 +24,15 @@ public:
   ObExprNotEqual();
   explicit ObExprNotEqual(common::ObIAllocator& alloc);
   virtual ~ObExprNotEqual(){};
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_stack, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
       const common::ObCompareCtx& cmp_ctx, common::ObCastCtx& cast_ctx);
 
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override
   {
diff --git a/src/sql/engine/expr/ob_expr_random.h b/src/sql/engine/expr/ob_expr_random.h
index 15f1b2880acafe4bb1ab77a1d8fb3cabcb1956cb..2ee6897a8009942735de42c14dbb540dd27c23b5 100644
--- a/src/sql/engine/expr/ob_expr_random.h
+++ b/src/sql/engine/expr/ob_expr_random.h
@@ -36,9 +36,9 @@ public:
   explicit ObExprRandom(common::ObIAllocator& alloc);
   virtual ~ObExprRandom();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   inline void set_seed_const(bool is_seed_const);
 
   // engine 3.0
diff --git a/src/sql/engine/expr/ob_expr_regexp.h b/src/sql/engine/expr/ob_expr_regexp.h
index 1cfd9f4bfd6d6c3b1ff2014ce5c71c4bae375b7b..de7bc4e75fa65c75d7da1b7330aa26e98f1ffb70 100644
--- a/src/sql/engine/expr/ob_expr_regexp.h
+++ b/src/sql/engine/expr/ob_expr_regexp.h
@@ -25,12 +25,12 @@ public:
   explicit ObExprRegexp(common::ObIAllocator& alloc);
   virtual ~ObExprRegexp();
 
-  virtual int assign(const ObExprOperator& other);
+  virtual int assign(const ObExprOperator& other) override;
 
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj, const common::ObObj& pattern, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& obj, const common::ObObj& pattern,
+      common::ObExprCtx& expr_ctx) const override;
   virtual inline void reset()
   {
     regexp_idx_ = common::OB_COMPACT_INVALID_INDEX;
diff --git a/src/sql/engine/expr/ob_expr_regexp_count.h b/src/sql/engine/expr/ob_expr_regexp_count.h
index a0088c928eba599ea074fd63940b7926cbb341c0..9a2e607cba7cfba5d8f6a3032e7b5d16ecd0bb19 100644
--- a/src/sql/engine/expr/ob_expr_regexp_count.h
+++ b/src/sql/engine/expr/ob_expr_regexp_count.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprRegexpCount(common::ObIAllocator& alloc);
   virtual ~ObExprRegexpCount();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_regexp_instr.h b/src/sql/engine/expr/ob_expr_regexp_instr.h
index 9fa6150df98f29cb4ba451adee340ecdfe17a46a..86704b6db81c86999bbc7ebd51a4e165d445b518 100644
--- a/src/sql/engine/expr/ob_expr_regexp_instr.h
+++ b/src/sql/engine/expr/ob_expr_regexp_instr.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprRegexpInstr(common::ObIAllocator& alloc);
   virtual ~ObExprRegexpInstr();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
   static int eval_regexp_instr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_regexp_like.h b/src/sql/engine/expr/ob_expr_regexp_like.h
index 161455ee93df8b99dd7d240635f939bc973c5057..22f709f065eddbc55a0cb235e595d46c70de0d76 100644
--- a/src/sql/engine/expr/ob_expr_regexp_like.h
+++ b/src/sql/engine/expr/ob_expr_regexp_like.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprRegexpLike(common::ObIAllocator& alloc);
   virtual ~ObExprRegexpLike();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_regexp_replace.h b/src/sql/engine/expr/ob_expr_regexp_replace.h
index f9d0e1404af5ded6a510acb35885a577bc1ed835..d99766a2bff5bf370dcd44d73f7ae8a2655fb35f 100644
--- a/src/sql/engine/expr/ob_expr_regexp_replace.h
+++ b/src/sql/engine/expr/ob_expr_regexp_replace.h
@@ -24,9 +24,9 @@ public:
   explicit ObExprRegexpReplace(common::ObIAllocator& alloc);
   virtual ~ObExprRegexpReplace();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_regexp_substr.h b/src/sql/engine/expr/ob_expr_regexp_substr.h
index a577d5117ca3b3400d3ca041131a503e0f8bfe95..5e9d3839b3064122a6098c15fa3932d8e6fdf466 100644
--- a/src/sql/engine/expr/ob_expr_regexp_substr.h
+++ b/src/sql/engine/expr/ob_expr_regexp_substr.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprRegexpSubstr(common::ObIAllocator& alloc);
   virtual ~ObExprRegexpSubstr();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_repeat.h b/src/sql/engine/expr/ob_expr_repeat.h
index d6739881bee6a8604089fdf695769c45580a6b90..63dbd3c74ff098e343487fc927b8bf97de45cf16 100644
--- a/src/sql/engine/expr/ob_expr_repeat.h
+++ b/src/sql/engine/expr/ob_expr_repeat.h
@@ -22,7 +22,7 @@ public:
   explicit ObExprRepeat(common::ObIAllocator& alloc);
   virtual ~ObExprRepeat();
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& text, ObExprResType& count, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& text, ObExprResType& count, common::ObExprTypeCtx& type_ctx) const override;
   ///@brief call function calc(), implementation of ObExprOperator::calc_result2()
   ///
   ///@param [out] result  result of RPEAT(str, count)
@@ -31,7 +31,7 @@ public:
   ///@param [in] allocator:ObExprStringBuf
   ///@return OB_SUCCESS success, others failure
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& text, const common::ObObj& count, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& text, const common::ObObj& count, common::ObExprCtx& expr_ctx) const override;
   static int calc(common::ObObj& result, const common::ObObj& text, const common::ObObj& count,
       common::ObIAllocator* allocator, const common::ObObjType res_type, const int64_t max_result_size);
   static int calc(common::ObObj& result, const common::ObObjType type, const common::ObString& text,
diff --git a/src/sql/engine/expr/ob_expr_replace.h b/src/sql/engine/expr/ob_expr_replace.h
index f2f27f92024e5f3fa9dcace614494bdb5a67164c..bde13f3e887a2cde7d89d71882913c5714a400e3 100644
--- a/src/sql/engine/expr/ob_expr_replace.h
+++ b/src/sql/engine/expr/ob_expr_replace.h
@@ -24,7 +24,7 @@ public:
   explicit ObExprReplace(common::ObIAllocator& alloc);
   virtual ~ObExprReplace();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
 
   static int calc(common::ObObj& result, const common::ObObj& text, const common::ObObj& from, const common::ObObj& to,
       common::ObExprStringBuf& string_buf);
diff --git a/src/sql/engine/expr/ob_expr_sinh.h b/src/sql/engine/expr/ob_expr_sinh.h
index 11a9e6b932ab7433621c524e6cc7db1a77e3f53c..8e8979866daa4d137702f8767aea61e60e040e06 100644
--- a/src/sql/engine/expr/ob_expr_sinh.h
+++ b/src/sql/engine/expr/ob_expr_sinh.h
@@ -20,8 +20,9 @@ class ObExprSinh : public ObFuncExprOperator {
 public:
   explicit ObExprSinh(common::ObIAllocator& alloc);
   virtual ~ObExprSinh();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(
+      ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_sqrt.h b/src/sql/engine/expr/ob_expr_sqrt.h
index 87a99a50e8e361b5cf899ba3d08c2b288b4e0036..10dd681418d947f8deb85e75b0590c0533c6d613 100644
--- a/src/sql/engine/expr/ob_expr_sqrt.h
+++ b/src/sql/engine/expr/ob_expr_sqrt.h
@@ -20,8 +20,8 @@ class ObExprSqrt : public ObFuncExprOperator {
 public:
   explicit ObExprSqrt(common::ObIAllocator& alloc);
   virtual ~ObExprSqrt();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_str_to_date.h b/src/sql/engine/expr/ob_expr_str_to_date.h
index 9399a441b791a8661efc227118416e3522589a40..f7edb9c288da36251ccd3a49d659b87c8c5d906a 100644
--- a/src/sql/engine/expr/ob_expr_str_to_date.h
+++ b/src/sql/engine/expr/ob_expr_str_to_date.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprStrToDate(common::ObIAllocator& alloc);
   virtual ~ObExprStrToDate();
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& date, ObExprResType& format, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& date, const common::ObObj& format, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& date, ObExprResType& format, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& date, const common::ObObj& format,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_strcmp.h b/src/sql/engine/expr/ob_expr_strcmp.h
index 6fd972b9775552e84e4c2d38d29f4035513018c6..1e3a3ae425baa4154dd06d739fadf0868f26d177 100644
--- a/src/sql/engine/expr/ob_expr_strcmp.h
+++ b/src/sql/engine/expr/ob_expr_strcmp.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprStrcmp(common::ObIAllocator& alloc);
   virtual ~ObExprStrcmp(){};
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override
   {
diff --git a/src/sql/engine/expr/ob_expr_subquery_greater_equal.h b/src/sql/engine/expr/ob_expr_subquery_greater_equal.h
index 39522b8f4957c64f1955c644b3ca60a03e201874..3d6462f05260ab39ffec5aa638dc18d47ed60eeb 100644
--- a/src/sql/engine/expr/ob_expr_subquery_greater_equal.h
+++ b/src/sql/engine/expr/ob_expr_subquery_greater_equal.h
@@ -30,7 +30,7 @@ public:
 
 private:
   virtual int compare_single_row(const common::ObNewRow& left_row, const common::ObNewRow& right_row,
-      common::ObExprCtx& expr_ctx, common::ObObj& result) const;
+      common::ObExprCtx& expr_ctx, common::ObObj& result) const override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObExprSubQueryGreaterEqual);
diff --git a/src/sql/engine/expr/ob_expr_subquery_greater_than.h b/src/sql/engine/expr/ob_expr_subquery_greater_than.h
index b689b696488a3287ed9754c2bccd4769f579e9d8..6653b86e9339f906a56a1bed9f26e8c82e4bd770 100644
--- a/src/sql/engine/expr/ob_expr_subquery_greater_than.h
+++ b/src/sql/engine/expr/ob_expr_subquery_greater_than.h
@@ -30,7 +30,7 @@ public:
 
 private:
   virtual int compare_single_row(const common::ObNewRow& left_row, const common::ObNewRow& right_row,
-      common::ObExprCtx& expr_ctx, common::ObObj& result) const;
+      common::ObExprCtx& expr_ctx, common::ObObj& result) const override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObExprSubQueryGreaterThan);
diff --git a/src/sql/engine/expr/ob_expr_subquery_less_equal.h b/src/sql/engine/expr/ob_expr_subquery_less_equal.h
index a62a7b924b06b5ff5f06752651461884d9563655..dccf9d6bd49fc640b910e1060633d26ddf935b87 100644
--- a/src/sql/engine/expr/ob_expr_subquery_less_equal.h
+++ b/src/sql/engine/expr/ob_expr_subquery_less_equal.h
@@ -30,7 +30,7 @@ public:
 
 private:
   virtual int compare_single_row(const common::ObNewRow& left_row, const common::ObNewRow& right_row,
-      common::ObExprCtx& expr_ctx, common::ObObj& result) const;
+      common::ObExprCtx& expr_ctx, common::ObObj& result) const override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObExprSubQueryLessEqual);
diff --git a/src/sql/engine/expr/ob_expr_subquery_less_than.h b/src/sql/engine/expr/ob_expr_subquery_less_than.h
index 0d4aed572bcec22ea96d6614951f6cdcd5bf1621..cd6a95e7d0c7ce32e373f2e25a049e84ff28d491 100644
--- a/src/sql/engine/expr/ob_expr_subquery_less_than.h
+++ b/src/sql/engine/expr/ob_expr_subquery_less_than.h
@@ -30,7 +30,7 @@ public:
 
 private:
   virtual int compare_single_row(const common::ObNewRow& left_row, const common::ObNewRow& right_row,
-      common::ObExprCtx& expr_ctx, common::ObObj& result) const;
+      common::ObExprCtx& expr_ctx, common::ObObj& result) const override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObExprSubQueryLessThan);
diff --git a/src/sql/engine/expr/ob_expr_subquery_not_equal.h b/src/sql/engine/expr/ob_expr_subquery_not_equal.h
index 2d4818a4234b594d8042f21a9c6fe0f168f72a38..2dbc08950a4736fb91a2ab99c2f65b7afff3b6a0 100644
--- a/src/sql/engine/expr/ob_expr_subquery_not_equal.h
+++ b/src/sql/engine/expr/ob_expr_subquery_not_equal.h
@@ -28,7 +28,7 @@ public:
 
 private:
   virtual int compare_single_row(const common::ObNewRow& left_row, const common::ObNewRow& right_row,
-      common::ObExprCtx& expr_ctx, common::ObObj& result) const;
+      common::ObExprCtx& expr_ctx, common::ObObj& result) const override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ObExprSubQueryNotEqual);
diff --git a/src/sql/engine/expr/ob_expr_subquery_ns_equal.h b/src/sql/engine/expr/ob_expr_subquery_ns_equal.h
index ed7fdc870e3c06cd089d3699cacdcc108164eda4..7b1d4224acaa6a1c44c12b9055f9c6300fd072b4 100644
--- a/src/sql/engine/expr/ob_expr_subquery_ns_equal.h
+++ b/src/sql/engine/expr/ob_expr_subquery_ns_equal.h
@@ -28,7 +28,7 @@ public:
 
 private:
   virtual int compare_single_row(const common::ObNewRow& left_row, const common::ObNewRow& right_row,
-      common::ObExprCtx& expr_ctx, common::ObObj& result) const;
+      common::ObExprCtx& expr_ctx, common::ObObj& result) const override;
   DISALLOW_COPY_AND_ASSIGN(ObExprSubQueryNSEqual);
 };
 }  // namespace sql
diff --git a/src/sql/engine/expr/ob_expr_subquery_ref.h b/src/sql/engine/expr/ob_expr_subquery_ref.h
index bd63ca64994e42a6e7cd726008964bf1e985cc06..6e4352ff9a4b67b45478679c20f3353c21d8ead4 100644
--- a/src/sql/engine/expr/ob_expr_subquery_ref.h
+++ b/src/sql/engine/expr/ob_expr_subquery_ref.h
@@ -46,11 +46,11 @@ public:
   explicit ObExprSubQueryRef(common::ObIAllocator& alloc);
   virtual ~ObExprSubQueryRef();
 
-  virtual int assign(const ObExprOperator& other);
+  virtual int assign(const ObExprOperator& other) override;
 
-  virtual void reset();
-  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const;
+  virtual void reset() override;
+  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int expr_eval(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
diff --git a/src/sql/engine/expr/ob_expr_substr.h b/src/sql/engine/expr/ob_expr_substr.h
index 4be55a9c916ad7ca53e39904cbe070aeaf1ea118..726f456683ba7b6ff3da8efbd23a10b3772fb286 100644
--- a/src/sql/engine/expr/ob_expr_substr.h
+++ b/src/sql/engine/expr/ob_expr_substr.h
@@ -23,13 +23,13 @@ public:
   explicit ObExprSubstr(common::ObIAllocator& alloc);
   virtual ~ObExprSubstr();
   virtual int calc_result2(common::ObObj& result, const common::ObObj& text, const common::ObObj& start_pos,
-      common::ObExprCtx& expr_ctx) const;
+      common::ObExprCtx& expr_ctx) const override;
   virtual int calc_result3(common::ObObj& result, const common::ObObj& text, const common::ObObj& start_pos,
-      const common::ObObj& length, common::ObExprCtx& expr_ctx) const;
-  virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_stack, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      const common::ObObj& length, common::ObExprCtx& expr_ctx) const override;
+  virtual int calc_result_typeN(ObExprResType& type, ObExprResType* types_stack, int64_t param_num,
+      common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
 
   static int substr(common::ObString& output, const common::ObString& input, const int64_t pos, const int64_t len,
       common::ObCollationType cs_type);
diff --git a/src/sql/engine/expr/ob_expr_substring_index.h b/src/sql/engine/expr/ob_expr_substring_index.h
index 1b4d59f0579146f9fe92d0679eadf017aafb71db..b454c6ec9ef2972921738cecd8c852534035d89d 100644
--- a/src/sql/engine/expr/ob_expr_substring_index.h
+++ b/src/sql/engine/expr/ob_expr_substring_index.h
@@ -23,9 +23,9 @@ public:
   explicit ObExprSubstringIndex(common::ObIAllocator& alloc);
   virtual ~ObExprSubstringIndex();
   virtual int calc_result_type3(ObExprResType& type, ObExprResType& str, ObExprResType& delim, ObExprResType& count,
-      common::ObExprTypeCtx& type_ctx) const;
+      common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result3(common::ObObj& result, const common::ObObj& str, const common::ObObj& delim,
-      const common::ObObj& count, common::ObExprCtx& expr_ctx) const;
+      const common::ObObj& count, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_sys_connect_by_path.h b/src/sql/engine/expr/ob_expr_sys_connect_by_path.h
index 0bcb7b1da24e7dcb6e903aa9e170de90c6c9bfa4..c47f619643f41096d8b912d79a4a550d58e49342 100644
--- a/src/sql/engine/expr/ob_expr_sys_connect_by_path.h
+++ b/src/sql/engine/expr/ob_expr_sys_connect_by_path.h
@@ -24,9 +24,9 @@ public:
   virtual ~ObExprSysConnectByPath()
   {}
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& left, const common::ObObj& right, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_sys_path(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   static int eval_sys_connect_by_path(
diff --git a/src/sql/engine/expr/ob_expr_sys_privilege_check.h b/src/sql/engine/expr/ob_expr_sys_privilege_check.h
index d099c37b9b78ce2aa5de9b65643f2e8ff2235b17..632e623e5c42a5e3ab92077ce9b97b43641dcef7 100644
--- a/src/sql/engine/expr/ob_expr_sys_privilege_check.h
+++ b/src/sql/engine/expr/ob_expr_sys_privilege_check.h
@@ -20,11 +20,11 @@ public:
   explicit ObExprSysPrivilegeCheck(common::ObIAllocator& alloc);
   virtual ~ObExprSysPrivilegeCheck();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
 
   /// obj_array(level, tenant, db, table)
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* obj_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* obj_array, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int eval_sys_privilege_check(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_timestamp_diff.h b/src/sql/engine/expr/ob_expr_timestamp_diff.h
index b628fabb60af52884becf569bb4fbb3b9d362e16..afda54f404c7ade3cd81e3caff7fb3510c289c14 100644
--- a/src/sql/engine/expr/ob_expr_timestamp_diff.h
+++ b/src/sql/engine/expr/ob_expr_timestamp_diff.h
@@ -22,10 +22,10 @@ public:
   explicit ObExprTimeStampDiff(common::ObIAllocator& alloc);
   virtual ~ObExprTimeStampDiff();
   virtual int calc_result_type3(ObExprResType& type, ObExprResType& unit, ObExprResType& left, ObExprResType& right,
-      common::ObExprTypeCtx& type_ctx) const;
+      common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result3(common::ObObj& result, const common::ObObj& unit, const common::ObObj& left,
-      const common::ObObj& right, common::ObExprCtx& expr_ctx) const;
-  virtual common::ObCastMode get_cast_mode() const
+      const common::ObObj& right, common::ObExprCtx& expr_ctx) const override;
+  virtual common::ObCastMode get_cast_mode() const override
   {
     return CM_NULL_ON_WARN;
   }
diff --git a/src/sql/engine/expr/ob_expr_timestamp_nvl.h b/src/sql/engine/expr/ob_expr_timestamp_nvl.h
index f6ae14c59b0dfaab23b0b8455a688d889f5e48a3..2fb1a7ffc0f9dec85396c6a88fe90ff5b98c10f6 100644
--- a/src/sql/engine/expr/ob_expr_timestamp_nvl.h
+++ b/src/sql/engine/expr/ob_expr_timestamp_nvl.h
@@ -22,9 +22,9 @@ public:
   explicit ObExprTimestampNvl(common::ObIAllocator& alloc);
   virtual ~ObExprTimestampNvl();
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_timestampnvl(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_to_days.h b/src/sql/engine/expr/ob_expr_to_days.h
index 055edef5c5622f4065c9456f129860b5ebc0f305..7dd240c3aec0f16b264e318f8fd885bcb20a0556 100644
--- a/src/sql/engine/expr/ob_expr_to_days.h
+++ b/src/sql/engine/expr/ob_expr_to_days.h
@@ -21,8 +21,9 @@ public:
   ObExprToDays();
   explicit ObExprToDays(common::ObIAllocator& alloc);
   virtual ~ObExprToDays();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& date, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& date, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(
+      ObExprResType& type, ObExprResType& date, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(common::ObObj& result, const common::ObObj& date, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_to_interval.h b/src/sql/engine/expr/ob_expr_to_interval.h
index ed415b9ffd83487a973f6dcd7d3ab64dfdf34fdd..cc7a6d120d155c5bbfda555515766185050e1eef 100644
--- a/src/sql/engine/expr/ob_expr_to_interval.h
+++ b/src/sql/engine/expr/ob_expr_to_interval.h
@@ -21,8 +21,8 @@ class ObExprToYMInterval : public ObFuncExprOperator {
 public:
   explicit ObExprToYMInterval(common::ObIAllocator& alloc);
   virtual ~ObExprToYMInterval();
-  int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
-  int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const;
+  int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
+  int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_yminterval(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
@@ -34,8 +34,8 @@ class ObExprToDSInterval : public ObFuncExprOperator {
 public:
   explicit ObExprToDSInterval(common::ObIAllocator& alloc);
   virtual ~ObExprToDSInterval();
-  int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
-  int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const;
+  int calc_result_type1(ObExprResType& type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
+  int calc_result1(common::ObObj& result, const common::ObObj& obj, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_dsinterval(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
 
@@ -48,9 +48,9 @@ public:
   explicit ObExprNumToYMInterval(common::ObIAllocator& alloc);
   virtual ~ObExprNumToYMInterval();
   int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   template <class T>
   static int calc_result_common(
       const T& obj1, const T& obj2, common::ObIAllocator& calc_buf, common::ObIntervalYMValue& ym_value);
@@ -66,9 +66,9 @@ public:
   explicit ObExprNumToDSInterval(common::ObIAllocator& alloc);
   virtual ~ObExprNumToDSInterval();
   int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  int calc_result2(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   template <class R, class T>
   static int calc_result_common(R& result, const T& obj1, const T& obj2, common::ObIAllocator& calc_buf);
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
diff --git a/src/sql/engine/expr/ob_expr_to_number.h b/src/sql/engine/expr/ob_expr_to_number.h
index 2b6122fe4c2d15471cf60247d8bf0b69e19b9417..1745bdda7e701330799861be3c318bd29a9c2884 100644
--- a/src/sql/engine/expr/ob_expr_to_number.h
+++ b/src/sql/engine/expr/ob_expr_to_number.h
@@ -38,7 +38,7 @@ public:
   virtual ~ObExprToNumber();
 
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_(const ObString& in_str, const ObString& in_fmt_str, ObIAllocator& alloc, number::ObNumber& res_nmb);
   // for engine 3.0
@@ -54,9 +54,9 @@ public:
   virtual ~ObExprToBinaryFloat();
 
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_(const ObString& in_str, const ObString& in_fmt_str, ObIAllocator& alloc, number::ObNumber& res_nmb);
   static int calc_to_binaryfloat_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
@@ -71,9 +71,9 @@ public:
   virtual ~ObExprToBinaryDouble();
 
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* objs, int64_t param_num, common::ObExprCtx& expr_ctx) const override;
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_binarydouble_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_to_temporal_base.h b/src/sql/engine/expr/ob_expr_to_temporal_base.h
index ad58f6ad7ec85cf82a802a9b55791d16830b801c..eebb94467f7d4f70df814acf95149cbfdac379ef 100644
--- a/src/sql/engine/expr/ob_expr_to_temporal_base.h
+++ b/src/sql/engine/expr/ob_expr_to_temporal_base.h
@@ -23,10 +23,10 @@ public:
   explicit ObExprToTemporalBase(common::ObIAllocator& alloc, ObExprOperatorType type, const char* name);
   virtual ~ObExprToTemporalBase()
   {}
-  virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types_array, int64_t param_num, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_typeN(ObExprResType& type, ObExprResType* types_array, int64_t param_num,
+      common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int set_my_result_from_ob_time(
       common::ObExprCtx& expr_ctx, common::ObTime& ob_time, common::ObObj& result) const = 0;
   virtual common::ObObjType get_my_target_obj_type() const = 0;
diff --git a/src/sql/engine/expr/ob_expr_trim.h b/src/sql/engine/expr/ob_expr_trim.h
index ac2e666dd6bf0213106efc1e68351855ed7308e2..ea601e2eec6a683c25d9c3a8ece0d2cc37a89f44 100644
--- a/src/sql/engine/expr/ob_expr_trim.h
+++ b/src/sql/engine/expr/ob_expr_trim.h
@@ -41,7 +41,7 @@ public:
       const common::ObFixedArray<size_t, common::ObIAllocator>&);
 
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override
   {
     return deduce_result_type(type, types, param_num, type_ctx);
   }
@@ -49,8 +49,8 @@ public:
   static int deduce_result_type(
       ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx);
 
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
@@ -84,10 +84,11 @@ public:
   explicit ObExprLtrim(common::ObIAllocator& alloc, ObExprOperatorType type, const char* name, int32_t param_num);
   virtual ~ObExprLtrim();
 
-  virtual int calc_result_type1(ObExprResType& res_type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const;
+  virtual int calc_result_type1(
+      ObExprResType& res_type, ObExprResType& type1, common::ObExprTypeCtx& type_ctx) const override;
 
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const
+      ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx) const override
   {
     return deduce_result_type(type, types, param_num, type_ctx);
   }
@@ -95,12 +96,13 @@ public:
   static int deduce_result_type(
       ObExprResType& type, ObExprResType* types, int64_t param_num, common::ObExprTypeCtx& type_ctx);
 
-  virtual int calc_result1(common::ObObj& res_obj, const common::ObObj& obj1, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result1(
+      common::ObObj& res_obj, const common::ObObj& obj1, common::ObExprCtx& expr_ctx) const override;
 
   int calc(common::ObObj& res_obj, const common::ObObj& obj1, common::ObExprCtx& expr_ctx, int64_t trim_type_val) const;
 
-  virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* objs_array, int64_t param_num, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_resultN(common::ObObj& result, const common::ObObj* objs_array, int64_t param_num,
+      common::ObExprCtx& expr_ctx) const override;
 
   static int calc_oracle_mode(common::ObObj& result, const int64_t trim_type, const common::ObString& pattern,
       const common::ObString& text, const common::ObObjType& res_type, common::ObExprCtx& expr_ctx,
diff --git a/src/sql/engine/expr/ob_expr_truncate.h b/src/sql/engine/expr/ob_expr_truncate.h
index 9e0ec117b16ef59626d817e268217f0eaa7c141f..c44c72a0807ab7c066f0af41e2af8f3e32134076 100644
--- a/src/sql/engine/expr/ob_expr_truncate.h
+++ b/src/sql/engine/expr/ob_expr_truncate.h
@@ -27,7 +27,7 @@ public:
 
   virtual int calc_result2(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
       common::ObExprCtx& expr_ctx) const override;
-  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const;
+  virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int set_trunc_val(
       common::ObObj& result, common::number::ObNumber& nmb, common::ObExprCtx& expr_ctx, common::ObObjType res_type);
 
diff --git a/src/sql/engine/expr/ob_expr_type_to_str.h b/src/sql/engine/expr/ob_expr_type_to_str.h
index 68faf7963894a1aca00811054d026ac1b3b2aa80..e1937f0cd83359a3dabca49b5c454fbc749a1fb0 100644
--- a/src/sql/engine/expr/ob_expr_type_to_str.h
+++ b/src/sql/engine/expr/ob_expr_type_to_str.h
@@ -105,8 +105,8 @@ class ObExprSetToStr : public ObExprTypeToStr {
 public:
   explicit ObExprSetToStr(common::ObIAllocator& alloc);
   virtual ~ObExprSetToStr();
-  virtual int calc(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+  virtual int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_str_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
@@ -119,8 +119,8 @@ class ObExprEnumToStr : public ObExprTypeToStr {
 public:
   explicit ObExprEnumToStr(common::ObIAllocator& alloc);
   virtual ~ObExprEnumToStr();
-  virtual int calc(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+  virtual int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_str_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
@@ -134,9 +134,9 @@ public:
   explicit ObExprSetToInnerType(common::ObIAllocator& alloc);
   virtual ~ObExprSetToInnerType();
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_inner_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
@@ -150,9 +150,9 @@ public:
   explicit ObExprEnumToInnerType(common::ObIAllocator& alloc);
   virtual ~ObExprEnumToInnerType();
   virtual int calc_result_type2(
-      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc(
-      common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2, common::ObExprCtx& expr_ctx) const;
+      ObExprResType& type, ObExprResType& type1, ObExprResType& type2, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc(common::ObObj& result, const common::ObObj& obj1, const common::ObObj& obj2,
+      common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int calc_to_inner_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_uid.h b/src/sql/engine/expr/ob_expr_uid.h
index ebbc441f267076df2429aa2201ee386659a0fa5f..e6ffc5565261f96c6494125c1e222e3907f64bc1 100644
--- a/src/sql/engine/expr/ob_expr_uid.h
+++ b/src/sql/engine/expr/ob_expr_uid.h
@@ -21,8 +21,8 @@ class ObExprUid : public ObFuncExprOperator {
 public:
   explicit ObExprUid(common::ObIAllocator& alloc);
   virtual ~ObExprUid();
-  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const override;
   static int eval_uid(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_unhex.h b/src/sql/engine/expr/ob_expr_unhex.h
index c545ce9906dfe3c32c8d7d38ca4a9ab35530d629..5a423f78221e36999c195a8c5e171e738a31b21d 100644
--- a/src/sql/engine/expr/ob_expr_unhex.h
+++ b/src/sql/engine/expr/ob_expr_unhex.h
@@ -21,10 +21,11 @@ class ObExprUnhex : public ObStringExprOperator {
 public:
   explicit ObExprUnhex(common::ObIAllocator& alloc);
   virtual ~ObExprUnhex();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const;
-  static int calc(
-      common::ObObj& result, const common::ObObj& text, common::ObCastCtx& cast_ctx, common::ObExprCtx& expr_ctx);
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(
+      ObExprResType& type, ObExprResType& text, common::ObExprTypeCtx& type_ctx) const override;
+  static int calc(common::ObObj& result, const common::ObObj& text, common::ObCastCtx& cast_ctx, common::ObExprCtx& expr_ctx);
+  virtual int calc_result1(
+      common::ObObj& result, const common::ObObj& text, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
   static int eval_unhex(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum);
 
diff --git a/src/sql/engine/expr/ob_expr_unix_timestamp.h b/src/sql/engine/expr/ob_expr_unix_timestamp.h
index 7940d85e848d6e3a14c17c0ee3c5d1c3d7e239f4..4370185cabc7ed564ef325c5b2775e4683ae7610 100644
--- a/src/sql/engine/expr/ob_expr_unix_timestamp.h
+++ b/src/sql/engine/expr/ob_expr_unix_timestamp.h
@@ -22,9 +22,9 @@ public:
   explicit ObExprUnixTimestamp(common::ObIAllocator& alloc);
   virtual ~ObExprUnixTimestamp();
   virtual int calc_result_typeN(
-      ObExprResType& type, ObExprResType* type_array, int64_t param, common::ObExprTypeCtx& type_ctx) const;
+      ObExprResType& type, ObExprResType* type_array, int64_t param, common::ObExprTypeCtx& type_ctx) const override;
   virtual int calc_resultN(
-      common::ObObj& result, const common::ObObj* date_param, int64_t param, common::ObExprCtx& expr_ctx) const;
+      common::ObObj& result, const common::ObObj* date_param, int64_t param, common::ObExprCtx& expr_ctx) const override;
   static int calc(
       common::ObObj& result, const common::ObObj& dt_date, const ObExprResType& res_type, common::ObCastCtx& cast_ctx);
   static int eval_unix_timestamp(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res);
diff --git a/src/sql/engine/expr/ob_expr_usec_to_time.h b/src/sql/engine/expr/ob_expr_usec_to_time.h
index 424ddbf8292f76339589b4bb4e7d3594550fcd16..9f9a9b95dc11fbfc62c4f8b23597b1deee04af24 100644
--- a/src/sql/engine/expr/ob_expr_usec_to_time.h
+++ b/src/sql/engine/expr/ob_expr_usec_to_time.h
@@ -20,8 +20,10 @@ class ObExprUsecToTime : public ObFuncExprOperator {
 public:
   explicit ObExprUsecToTime(common::ObIAllocator& alloc);
   virtual ~ObExprUsecToTime();
-  virtual int calc_result_type1(ObExprResType& type, ObExprResType& usec, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result1(common::ObObj& result, const common::ObObj& usec, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result_type1(
+      ObExprResType& type, ObExprResType& usec, common::ObExprTypeCtx& type_ctx) const override;
+  virtual int calc_result1(
+      common::ObObj& result, const common::ObObj& usec, common::ObExprCtx& expr_ctx) const override;
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
 private:
diff --git a/src/sql/engine/expr/ob_expr_user.h b/src/sql/engine/expr/ob_expr_user.h
index d1706efee220f915f1b941c4fc1e3552acdb6135..3cebcc39a0a717a67325246dd277fe8a33eefdf5 100644
--- a/src/sql/engine/expr/ob_expr_user.h
+++ b/src/sql/engine/expr/ob_expr_user.h
@@ -22,7 +22,7 @@ public:
   explicit ObExprUser(common::ObIAllocator& alloc);
   virtual ~ObExprUser();
   virtual int calc_result_type0(ObExprResType& type, common::ObExprTypeCtx& type_ctx) const;
-  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const;
+  virtual int calc_result0(common::ObObj& result, common::ObExprCtx& expr_ctx) const override;
   static int eval_user(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum);
   virtual int cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/expr/ob_expr_user_can_access_obj.h b/src/sql/engine/expr/ob_expr_user_can_access_obj.h
index 5b3e7c14fdc25bbbe0a176590b54598469cc8d33..977182649b215b273aeaf3b681fef8c5a979d64f 100644
--- a/src/sql/engine/expr/ob_expr_user_can_access_obj.h
+++ b/src/sql/engine/expr/ob_expr_user_can_access_obj.h
@@ -25,10 +25,10 @@ public:
   explicit ObExprUserCanAccessObj(common::ObIAllocator& alloc);
   virtual ~ObExprUserCanAccessObj();
   virtual int calc_result_type3(ObExprResType& type, ObExprResType& arg1, ObExprResType& arg2, ObExprResType& arg3,
-      common::ObExprTypeCtx& type_ctx) const;
+      common::ObExprTypeCtx& type_ctx) const override;
 
   virtual int calc_result3(common::ObObj& result, const common::ObObj& arg1, const common::ObObj& arg2,
-      const common::ObObj& arg3, common::ObExprCtx& expr_ctx) const;
+      const common::ObObj& arg3, common::ObExprCtx& expr_ctx) const override;
 
   virtual int cg_expr(ObExprCGCtx& expr_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const override;
 
diff --git a/src/sql/engine/join/ob_basic_nested_loop_join.h b/src/sql/engine/join/ob_basic_nested_loop_join.h
index 3712e346534dfb5c229f5a01303d8738f6747447..e947f0b7036ea8cd296ef576d48297db14c51653 100644
--- a/src/sql/engine/join/ob_basic_nested_loop_join.h
+++ b/src/sql/engine/join/ob_basic_nested_loop_join.h
@@ -73,8 +73,8 @@ protected:
 public:
   explicit ObBasicNestedLoopJoin(common::ObIAllocator& alloc);
   virtual ~ObBasicNestedLoopJoin();
-  virtual void reset();
-  virtual void reuse();
+  virtual void reset() override;
+  virtual void reuse() override;
   int init_param_count(int64_t count)
   {
     return init_array_size<>(rescan_params_, count);
@@ -95,7 +95,7 @@ public:
       other_join_conds_, N_INNER_GET, is_inner_get_, N_SELF_JOIN, is_self_join_);
 
 protected:
-  int get_next_left_row(ObJoinCtx& join_ctx) const;
+  int get_next_left_row(ObJoinCtx& join_ctx) const override;
   int prepare_rescan_params(ObBasicNestedLoopJoinCtx& join_ctx) const;
   inline bool use_batch_index_join(ObPhyOperatorType right_op_type) const
   {
diff --git a/src/sql/engine/join/ob_hash_join_op.h b/src/sql/engine/join/ob_hash_join_op.h
index 35a1d3060bff7f29d67effe351ac733cd8a2455f..532ac3d2da1e64b8e85e05a15043a7d8507dc4af 100644
--- a/src/sql/engine/join/ob_hash_join_op.h
+++ b/src/sql/engine/join/ob_hash_join_op.h
@@ -421,7 +421,7 @@ private:
   int next();
   int join_end_operate();
   int join_end_func_end();
-  int get_next_left_row();
+  int get_next_left_row() override;
   int reuse_for_next_chunk();
   int load_next_chunk();
   int build_hash_table_for_nest_loop(int64_t& num_left_rows);
@@ -448,7 +448,7 @@ private:
   int split_partition_and_build_hash_table(int64_t& num_left_rows);
   int recursive_process(bool& need_not_read_right);
   int adaptive_process(bool& need_not_read_right);
-  int get_next_right_row();
+  int get_next_right_row() override;
   int read_right_operate();
   int calc_hash_value(const ObIArray<ObExpr*>& join_keys, const ObIArray<ObHashFunc>& hash_funcs, uint64_t& hash_value);
   int calc_right_hash_value();
diff --git a/src/sql/engine/join/ob_merge_join.h b/src/sql/engine/join/ob_merge_join.h
index 6c5dad3b2f8b5da2b374df3add9a0b480c89fd9e..557b107136395d139813f237a6bdb2f7e128e1cc 100644
--- a/src/sql/engine/join/ob_merge_join.h
+++ b/src/sql/engine/join/ob_merge_join.h
@@ -100,9 +100,9 @@ private:
 public:
   explicit ObMergeJoin(common::ObIAllocator& alloc);
   virtual ~ObMergeJoin();
-  virtual void reset();
-  virtual void reuse();
-  virtual int rescan(ObExecContext& exec_ctx) const;
+  virtual void reset() override;
+  virtual void reuse() override;
+  virtual int rescan(ObExecContext& exec_ctx) const override;
   virtual int switch_iterator(ObExecContext& ctx) const override;
   inline void set_left_unique(const bool u)
   {
@@ -137,19 +137,19 @@ private:
   // state operation and transfer functions.
   typedef int (ObMergeJoin::*state_operation_func_type)(ObMergeJoinCtx& join_ctx) const;
   typedef int (ObMergeJoin::*state_function_func_type)(ObMergeJoinCtx& join_ctx, const common::ObNewRow*& row) const;
-  virtual int inner_get_next_row(ObExecContext& exec_ctx, const common::ObNewRow*& row) const;
+  virtual int inner_get_next_row(ObExecContext& exec_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& exec_ctx) const;
+  virtual int inner_open(ObExecContext& exec_ctx) const override;
   /**
    * @brief close operator, not including children operators.
    * Every op should implement this method.
    */
-  virtual int inner_close(ObExecContext& exec_ctx) const;
-  virtual int inner_create_operator_ctx(ObExecContext& exec_ctx, ObPhyOperatorCtx*& op_ctx) const;
+  virtual int inner_close(ObExecContext& exec_ctx) const override;
+  virtual int inner_create_operator_ctx(ObExecContext& exec_ctx, ObPhyOperatorCtx*& op_ctx) const override;
 
 private:
   // JS_JOIN_END state operation and transfer functions.
diff --git a/src/sql/engine/join/ob_nested_loop_join.h b/src/sql/engine/join/ob_nested_loop_join.h
index 9fab9dde7d67890bb12d7316e7dca7a40d8b5241..c322d10cd84bcc96054e6eb49fe78c6b232e5474 100644
--- a/src/sql/engine/join/ob_nested_loop_join.h
+++ b/src/sql/engine/join/ob_nested_loop_join.h
@@ -61,8 +61,8 @@ private:
 public:
   explicit ObNestedLoopJoin(common::ObIAllocator& alloc);
   virtual ~ObNestedLoopJoin();
-  virtual void reset();
-  virtual void reuse();
+  virtual void reset() override;
+  virtual void reuse() override;
   virtual int rescan(ObExecContext& exec_ctx) const;
   virtual int switch_iterator(ObExecContext& ctx) const override;
 
@@ -96,14 +96,14 @@ private:
   typedef int (ObNestedLoopJoin::*state_operation_func_type)(ObNestedLoopJoinCtx& join_ctx) const;
   typedef int (ObNestedLoopJoin::*state_function_func_type)(
       ObNestedLoopJoinCtx& join_ctx, const common::ObNewRow*& row) const;
-  virtual int inner_get_next_row(ObExecContext& exec_ctx, const common::ObNewRow*& row) const;
+  virtual int inner_get_next_row(ObExecContext& exec_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& exec_ctx) const;
-  virtual int inner_create_operator_ctx(ObExecContext& exec_ctx, ObPhyOperatorCtx*& op_ctx) const;
+  virtual int inner_open(ObExecContext& exec_ctx) const override;
+  virtual int inner_create_operator_ctx(ObExecContext& exec_ctx, ObPhyOperatorCtx*& op_ctx) const override;
   int prepare_rescan_params_for_group(ObNestedLoopJoinCtx& join_ctx) const;
   // JS_JOIN_END state operation and transfer functions.
   int join_end_operate(ObNestedLoopJoinCtx& join_ctx) const;
@@ -124,9 +124,8 @@ private:
   state_operation_func_type state_operation_func_[JS_STATE_COUNT];
   state_function_func_type state_function_func_[JS_STATE_COUNT][FT_TYPE_COUNT];
   // nested loop join with index seek, batch
-  int batch_index_join_get_next(ObExecContext &exec_ctx,
-                                const common::ObNewRow *&row) const;
-  int reset_rescan_params(ObExecContext &ctx) const;
+  int batch_index_join_get_next(ObExecContext& exec_ctx, const common::ObNewRow*& row) const;
+  int reset_rescan_params(ObExecContext& ctx) const;
 
 private:
   int bij_fill_left_rows(ObExecContext& exec_ctx) const;
diff --git a/src/sql/engine/px/exchange/ob_px_transmit.h b/src/sql/engine/px/exchange/ob_px_transmit.h
index 69392f4e0626fcc634e3dd4f0cddb512b1e69cd0..25eaeb86fa35db5b015b2f509e287ddc32cfa2f1 100644
--- a/src/sql/engine/px/exchange/ob_px_transmit.h
+++ b/src/sql/engine/px/exchange/ob_px_transmit.h
@@ -132,10 +132,10 @@ protected:
     return partition_id_idx_;
   }
   virtual int do_transmit(ObExecContext& ctx) const = 0;
-  int inner_open(ObExecContext& exec_ctx) const;
-  int get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
+  int inner_open(ObExecContext& exec_ctx) const override;
+  int get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
   int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
-  int inner_close(ObExecContext& exec_ctx) const;
+  int inner_close(ObExecContext& exec_ctx) const override;
   static int link_ch_sets(
       ObPxTaskChSet& ch_set, common::ObIArray<dtl::ObDtlChannel*>& channels, dtl::ObDtlFlowControl* dfc = nullptr);
   int send_rows(ObExecContext& exec_ctx, ObPxTransmitCtx& transmit_ctx, ObSliceIdxCalc& slice_calc) const;
diff --git a/src/sql/engine/px/ob_granule_iterator.h b/src/sql/engine/px/ob_granule_iterator.h
index cb97c65f4d157d15e51d6d324cf8b249370a4011..892b6c1c3997556596b8799271350b31f0134941 100644
--- a/src/sql/engine/px/ob_granule_iterator.h
+++ b/src/sql/engine/px/ob_granule_iterator.h
@@ -163,7 +163,7 @@ public:
   virtual int inner_close(ObExecContext& ctx) const override;
   virtual int inner_create_operator_ctx(ObExecContext& ctx, ObPhyOperatorCtx*& op_ctx) const;
   virtual int inner_get_next_row(ObExecContext& exec_ctx, const common::ObNewRow*& row) const override;
-  virtual int create_operator_input(ObExecContext& ctx) const;
+  virtual int create_operator_input(ObExecContext& ctx) const override;
   virtual OperatorOpenOrder get_operator_open_order(ObExecContext& ctx) const override
   {
     UNUSED(ctx);
diff --git a/src/sql/engine/subquery/ob_subplan_filter.h b/src/sql/engine/subquery/ob_subplan_filter.h
index 195669654ed48709fd39791c93c37f3238e7db0f..038cd66c37545f998698d52ed08f04e2cfd2446a 100644
--- a/src/sql/engine/subquery/ob_subplan_filter.h
+++ b/src/sql/engine/subquery/ob_subplan_filter.h
@@ -26,9 +26,9 @@ public:
   explicit ObSubPlanFilter(common::ObIAllocator& alloc);
   virtual ~ObSubPlanFilter();
 
-  void reset();
-  void reuse();
-  int rescan(ObExecContext& ctx) const;
+  void reset() override;
+  void reuse() override;
+  int rescan(ObExecContext& ctx) const override;
 
   /**
    * @brief add rescan param to subplan filter
@@ -65,7 +65,7 @@ public:
   {
     return update_set_;
   }
-  virtual int open(ObExecContext& ctx) const;
+  virtual int open(ObExecContext& ctx) const override;
   virtual int switch_iterator(ObExecContext& ctx) const override;
 
 private:
@@ -74,34 +74,34 @@ private:
    * @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 called by get_next_row(), get a row from the child operator or row_store
    * @param ctx[in], execute context
    * @param row[out], ObNewRow 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 wrap the object of ObExprCtx, and reset calc_buf
    * @param exec_ctx[in], execute context
    * @param expr_ctx[out], sql expression calculate buffer context
    * @return if success, return OB_SUCCESS
    */
-  virtual int wrap_expr_ctx(ObExecContext& exec_ctx, common::ObExprCtx& expr_ctx) const;
+  virtual int wrap_expr_ctx(ObExecContext& exec_ctx, common::ObExprCtx& expr_ctx) const override;
   int prepare_rescan_params(ObExecContext& ctx, const common::ObNewRow& row) const;
   int prepare_onetime_exprs(ObExecContext& ctx) const;
-  virtual int64_t to_string_kv(char* buf, const int64_t buf_len) const;
+  virtual int64_t to_string_kv(char* buf, const int64_t buf_len) const override;
   int handle_update_set(ObSubPlanFilterCtx* subplan_ctx, const common::ObNewRow*& row) const;
   int construct_array_params(ObExecContext& ctx) const;
   int reset_rescan_params(ObExecContext &ctx) const;
diff --git a/src/sql/engine/table/ob_block_sample_scan.h b/src/sql/engine/table/ob_block_sample_scan.h
index 17209ad7b347b7973c51585754099aebdafc94f4..2a3ad749340d8c776e54dfc5d05eed41fe2b0cb5 100644
--- a/src/sql/engine/table/ob_block_sample_scan.h
+++ b/src/sql/engine/table/ob_block_sample_scan.h
@@ -40,8 +40,8 @@ public:
   virtual ~ObBlockSampleScan()
   {}
 
-  virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
-  virtual int init_op_ctx(ObExecContext& ctx) const;
+  virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
+  virtual int init_op_ctx(ObExecContext& ctx) const override;
   inline void set_sample_info(const common::SampleInfo& sample_info)
   {
     sample_info_ = sample_info;
@@ -54,7 +54,7 @@ public:
   {
     return sample_info_;
   }
-  virtual int prepare_scan_param(ObExecContext& ctx) const;
+  virtual int prepare_scan_param(ObExecContext& ctx) const override;
   OB_INLINE virtual bool need_filter_row() const override
   {
     return true;
diff --git a/src/sql/engine/table/ob_multi_part_table_scan.h b/src/sql/engine/table/ob_multi_part_table_scan.h
index b147a7304d5714c40cec0a13bae2909a4c43828e..085e3aeb6e3bd68451266343a318d886237ee8a8 100644
--- a/src/sql/engine/table/ob_multi_part_table_scan.h
+++ b/src/sql/engine/table/ob_multi_part_table_scan.h
@@ -27,8 +27,8 @@ public:
   {}
   virtual ~ObMultiPartTableScanInput();
   virtual void reset() override;
-  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
   {
     return PHY_MULTI_PART_TABLE_SCAN;
   };
@@ -68,15 +68,15 @@ private:
 public:
   explicit ObMultiPartTableScan(common::ObIAllocator& allocator);
   virtual ~ObMultiPartTableScan();
-  virtual int rescan(ObExecContext& ctx) const;
+  virtual int rescan(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_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const;
+  virtual int inner_open(ObExecContext& ctx) const override;
+  virtual int inner_close(ObExecContext& ctx) const override;
+  virtual int inner_get_next_row(ObExecContext& ctx, const common::ObNewRow*& row) const override;
   virtual int create_operator_input(ObExecContext& ctx) const override final;
   virtual int init_op_ctx(ObExecContext& ctx) const override final;
   void get_used_range_count(ObExecContext& ctx, int64_t& range_count) const;
diff --git a/src/sql/engine/table/ob_table_row_store.h b/src/sql/engine/table/ob_table_row_store.h
index 3835f1085d20ba83ef4682569bd532c29eb0445c..55bf10d4fef14bec62d638d869acf639ff95138e 100644
--- a/src/sql/engine/table/ob_table_row_store.h
+++ b/src/sql/engine/table/ob_table_row_store.h
@@ -33,8 +33,8 @@ public:
     multi_row_store_.reset();
     // deserialize_allocator_ cannot be reset because it is only set once when creating operator input
   }
-  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
   {
     return PHY_TABLE_ROW_STORE;
   }
@@ -42,7 +42,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;
 
 private:
   common::ObFixedArray<common::ObRowStore*, common::ObIAllocator> multi_row_store_;
diff --git a/src/sql/engine/table/ob_table_row_store_op.h b/src/sql/engine/table/ob_table_row_store_op.h
index e1f0502e28f646dadeaae07710bfe80969312925..02860d94905f73d8ac5d618b8615a07b3070c071 100644
--- a/src/sql/engine/table/ob_table_row_store_op.h
+++ b/src/sql/engine/table/ob_table_row_store_op.h
@@ -41,7 +41,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;
 
 private:
   // One partition corresponds to one row store
diff --git a/src/sql/executor/ob_distributed_job_control.h b/src/sql/executor/ob_distributed_job_control.h
index 64bcfb308566a65d2ae8d8d2bedc35e55951e6d4..a0d8bef36383854a5e799a4755c8da5b1c55c4dc 100644
--- a/src/sql/executor/ob_distributed_job_control.h
+++ b/src/sql/executor/ob_distributed_job_control.h
@@ -22,7 +22,7 @@ public:
   ObDistributedJobControl();
   virtual ~ObDistributedJobControl();
 
-  virtual int get_ready_jobs(common::ObIArray<ObJob*>& jobs, bool serial_sched = false) const;
+  virtual int get_ready_jobs(common::ObIArray<ObJob*>& jobs, bool serial_sched = false) const override;
   virtual int sort_job_scan_part_locs(ObExecContext& ctx) override;
   virtual int init_job_finish_queue(ObExecContext& ctx) override;
   int get_root_job(ObJob*& root_job) const;
diff --git a/src/sql/executor/ob_remote_executor_processor.h b/src/sql/executor/ob_remote_executor_processor.h
index 6c150afb9535adfde9c2968bc1e637b4c2c6a975..f8d489ac81bd15d02dff66b33c3f1ee1f4a68e1d 100644
--- a/src/sql/executor/ob_remote_executor_processor.h
+++ b/src/sql/executor/ob_remote_executor_processor.h
@@ -108,15 +108,15 @@ public:
   {}
   virtual ~ObRpcRemoteExecuteP()
   {}
-  virtual int init();
+  virtual int init() override;
 
 protected:
   virtual int send_result_to_controller(ObExecContext& exec_ctx, const ObPhysicalPlan& plan) override;
-  virtual int before_process();
-  virtual int process();
-  virtual int before_response();
-  virtual int after_process();
-  virtual void cleanup();
+  virtual int before_process() override;
+  virtual int process() override;
+  virtual int before_response() override;
+  virtual int after_process() override;
+  virtual void cleanup() override;
   virtual void clean_result_buffer() override;
 
 private:
@@ -133,15 +133,15 @@ public:
   {}
   virtual ~ObRpcRemoteSyncExecuteP()
   {}
-  virtual int init();
+  virtual int init() override;
 
 protected:
   virtual int send_result_to_controller(ObExecContext& exec_ctx, const ObPhysicalPlan& plan) override;
-  virtual int before_process();
-  virtual int process();
-  virtual int before_response();
-  virtual int after_process();
-  virtual void cleanup();
+  virtual int before_process() override;
+  virtual int process() override;
+  virtual int before_response() override;
+  virtual int after_process() override;
+  virtual void cleanup() override;
   virtual void clean_result_buffer() override;
 };
 
@@ -153,16 +153,16 @@ public:
   {}
   virtual ~ObRpcRemoteASyncExecuteP()
   {}
-  virtual int init();
+  virtual int init() override;
   ObRemoteTask& get_arg()
   {
     return arg_;
   }
-  virtual int before_process();
-  virtual int process();
-  virtual int before_response();
-  virtual int after_process();
-  virtual void cleanup();
+  virtual int before_process() override;
+  virtual int process() override;
+  virtual int before_response() override;
+  virtual int after_process() override;
+  virtual void cleanup() override;
   void set_from_batch()
   {
     is_from_batch_ = true;
diff --git a/src/sql/executor/ob_slice_calc.h b/src/sql/executor/ob_slice_calc.h
index 6614705449198d65b2c9164ae1cb58ee2b742566..70cd56eff1649bdf4cd3012786f07ffd3713cf1e 100644
--- a/src/sql/executor/ob_slice_calc.h
+++ b/src/sql/executor/ob_slice_calc.h
@@ -88,7 +88,7 @@ public:
   {}
   virtual ~ObAllToOneSliceIdxCalc() = default;
   virtual int get_slice_idx(const common::ObNewRow& row, int64_t& slice_idx) override;
-  virtual int get_slice_idx(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, int64_t& slice_idx);
+  virtual int get_slice_idx(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, int64_t& slice_idx) override;
 
 protected:
 };
@@ -135,7 +135,8 @@ public:
   typedef common::hash::ObHashMap<int64_t, int64_t, common::hash::NoPthreadDefendMode> PartId2ArrayIdxMap;
   typedef common::hash::ObHashMap<int64_t, int64_t, common::hash::NoPthreadDefendMode> SubPartId2ArrayIdxMap;
 
-  virtual ~ObRepartSliceIdxCalc() {}
+  virtual ~ObRepartSliceIdxCalc()
+  {}
   virtual int get_slice_idx(const common::ObNewRow& row, int64_t& slice_idx) override;
 
   virtual int get_slice_idx(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, int64_t& slice_idx) override;
@@ -314,7 +315,8 @@ public:
   {}
 
   virtual int get_slice_indexes(const common::ObNewRow& row, SliceIdxArray& slice_idx_array) override;
-  virtual int get_slice_indexes(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, SliceIdxArray& slice_idx_array);
+  virtual int get_slice_indexes(
+      const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, SliceIdxArray& slice_idx_array) override;
 
 private:
   const ChannelIdxArray& channel_idx_;
@@ -342,7 +344,8 @@ public:
   {}
 
   virtual int get_slice_indexes(const common::ObNewRow& row, SliceIdxArray& slice_idx_array) override;
-  virtual int get_slice_indexes(const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, SliceIdxArray& slice_idx_array);
+  virtual int get_slice_indexes(
+      const ObIArray<ObExpr*>& exprs, ObEvalCtx& eval_ctx, SliceIdxArray& slice_idx_array) override;
 
 private:
   uint64_t slice_cnt_;
@@ -379,7 +382,7 @@ public:
   int calc_hash_value(const ObObj& obj, const ObObjType type, const ObCollationType cs_type, uint64_t& hash_val);
   int calc_hash_value(ObEvalCtx& eval_ctx, uint64_t& hash_val);
   int get_multi_hash_value(const ObNewRow& row, uint64_t& hash_val);
-  virtual int get_slice_idx(const ObNewRow& row, int64_t& slice_idx);
+  virtual int get_slice_idx(const ObNewRow& row, int64_t& slice_idx) override;
   int get_slice_idx(const ObIArray<ObExpr*>& row, ObEvalCtx& eval_ctx, int64_t& slice_idx) override;
 
   common::ObExprCtx* expr_ctx_;
diff --git a/src/sql/optimizer/ob_log_del_upd.h b/src/sql/optimizer/ob_log_del_upd.h
index 85370b6ee32c2c1938b2435f99a7b306a6bbee6f..46bce9d864008413ab0c90cd16277e05e6d9ccad 100644
--- a/src/sql/optimizer/ob_log_del_upd.h
+++ b/src/sql/optimizer/ob_log_del_upd.h
@@ -246,7 +246,7 @@ protected:
   int calculate_table_location(uint64_t loc_table_id, uint64_t ref_table_id, const ObPartHint* part_hint,
       ObTablePartitionInfo& table_partition_info);
   int alloc_partition_id_expr(ObAllocExprContext& ctx);
-  virtual int allocate_expr_post(ObAllocExprContext &ctx);
+  virtual int allocate_expr_post(ObAllocExprContext &ctx) override;
   int alloc_shadow_pk_column_for_gui(ObAllocExprContext& ctx);
   virtual int need_multi_table_dml(AllocExchContext& ctx, ObShardingInfo& sharding_info, bool& is_needed);
   int check_multi_table_dml_for_px(AllocExchContext& ctx, ObShardingInfo* source_sharding,
diff --git a/src/sql/optimizer/ob_log_limit.h b/src/sql/optimizer/ob_log_limit.h
index 72441bff7fd69273875c20d665de665107ef801d..633665141ee4af201c5472450a3b970f244a8190 100644
--- a/src/sql/optimizer/ob_log_limit.h
+++ b/src/sql/optimizer/ob_log_limit.h
@@ -88,8 +88,8 @@ public:
     return has_union_child_;
   }
   virtual int est_cost() override;
-  virtual int allocate_granule_pre(AllocGIContext &ctx);
-  virtual int allocate_granule_post(AllocGIContext &ctx);
+  virtual int allocate_granule_pre(AllocGIContext &ctx) override;
+  virtual int allocate_granule_post(AllocGIContext &ctx) override;
   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;
diff --git a/src/sql/optimizer/ob_optimizer_partition_location_cache.h b/src/sql/optimizer/ob_optimizer_partition_location_cache.h
index 5e869c4b81180286ff8ed6455d493c457d679d23..a353d5264c8149fd9971626c84212c5189e8aea5 100644
--- a/src/sql/optimizer/ob_optimizer_partition_location_cache.h
+++ b/src/sql/optimizer/ob_optimizer_partition_location_cache.h
@@ -23,7 +23,7 @@ public:
   ObOptimizerPartitionLocationCache(common::ObIAllocator& allocator, share::ObIPartitionLocationCache* location_cache);
   virtual ~ObOptimizerPartitionLocationCache();
 
-  virtual PartitionLocationCacheType get_type() const
+  virtual PartitionLocationCacheType get_type() const override
   {
     return ObOptimizerPartitionLocationCache::PART_LOC_CACHE_TYPE_OPTIMIZER;
   }
@@ -69,7 +69,7 @@ public:
   virtual int nonblock_renew_with_limiter(
       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;
   inline share::ObIPartitionLocationCache* get_location_cache()
   {
     return location_cache_;
diff --git a/src/sql/resolver/ddl/ob_alter_tablegroup_stmt.h b/src/sql/resolver/ddl/ob_alter_tablegroup_stmt.h
index 67d68cd7589c2b4193cf5957ea16c36e03924931..30feb27e6b48f3cf7085d0e8e767583f8a8dfedb 100644
--- a/src/sql/resolver/ddl/ob_alter_tablegroup_stmt.h
+++ b/src/sql/resolver/ddl/ob_alter_tablegroup_stmt.h
@@ -32,7 +32,7 @@ public:
   int add_table_item(const obrpc::ObTableItem& table_item);
   void set_tablegroup_name(const common::ObString& tablegroup_name);
   obrpc::ObAlterTablegroupArg& get_alter_tablegroup_arg();
-  virtual obrpc::ObDDLArg& get_ddl_arg()
+  virtual obrpc::ObDDLArg& get_ddl_arg() override
   {
     return alter_tablegroup_arg_;
   }
diff --git a/src/sql/resolver/ddl/ob_create_table_resolver.h b/src/sql/resolver/ddl/ob_create_table_resolver.h
index c19b791d5014e9cddcc64e3023bc82b60e393d8d..4e2c0d618f514e33463cd140747537780a6f8f3a 100644
--- a/src/sql/resolver/ddl/ob_create_table_resolver.h
+++ b/src/sql/resolver/ddl/ob_create_table_resolver.h
@@ -41,7 +41,7 @@ public:
   explicit ObCreateTableResolver(ObResolverParams& params);
   virtual ~ObCreateTableResolver();
 
-  virtual int resolve(const ParseNode& parse_tree);
+  virtual int resolve(const ParseNode& parse_tree) override;
 
 private:
   enum ResolveRule { RESOLVE_ALL = 0, RESOLVE_COL_ONLY, RESOLVE_NON_COL };
diff --git a/src/sql/resolver/ddl/ob_create_tablegroup_stmt.h b/src/sql/resolver/ddl/ob_create_tablegroup_stmt.h
index 6153cb1003c8cbeac5a8ccb05d3cb1c2192a6d62..bbf09639c5d7325b135913246a6250d32b65e185 100644
--- a/src/sql/resolver/ddl/ob_create_tablegroup_stmt.h
+++ b/src/sql/resolver/ddl/ob_create_tablegroup_stmt.h
@@ -33,7 +33,7 @@ public:
   virtual int set_primary_zone(const common::ObString& zone) override;
   virtual int set_locality(const common::ObString& locality) override;
   obrpc::ObCreateTablegroupArg& get_create_tablegroup_arg();
-  virtual obrpc::ObDDLArg& get_ddl_arg()
+  virtual obrpc::ObDDLArg& get_ddl_arg() override
   {
     return create_tablegroup_arg_;
   }
diff --git a/src/sql/resolver/dml/ob_merge_stmt.h b/src/sql/resolver/dml/ob_merge_stmt.h
index f9d2998040a5e05f7f40acac0d420855350fb4c8..0ba81de4a6bc1c2fc5147479919814bc5f4eed63 100644
--- a/src/sql/resolver/dml/ob_merge_stmt.h
+++ b/src/sql/resolver/dml/ob_merge_stmt.h
@@ -105,7 +105,7 @@ public:
   DECLARE_VIRTUAL_TO_STRING;
 
 protected:
-  virtual int inner_get_relation_exprs(RelExprCheckerBase& expr_checker);
+  virtual int inner_get_relation_exprs(RelExprCheckerBase& expr_checker) override;
 
 private:
   uint64_t source_table_id_;
diff --git a/src/sql/resolver/dml/ob_select_resolver.h b/src/sql/resolver/dml/ob_select_resolver.h
index e081548c6f323f441e41f2496ba0582bd1b1df94..7e927224b9138b644930d3040f490cc5766a9c06 100644
--- a/src/sql/resolver/dml/ob_select_resolver.h
+++ b/src/sql/resolver/dml/ob_select_resolver.h
@@ -170,7 +170,7 @@ public:
   explicit ObSelectResolver(ObResolverParams& params);
   virtual ~ObSelectResolver();
 
-  virtual int resolve(const ParseNode& parse_tree);
+  virtual int resolve(const ParseNode& parse_tree) override;
   ObSelectStmt* get_select_stmt();
   void set_calc_found_rows(bool found_rows)
   {
@@ -180,15 +180,15 @@ public:
   {
     has_top_limit_ = has_top_limit;
   }
-  virtual int resolve_child_stmt(const ParseNode& parse_tree)
+  virtual int resolve_child_stmt(const ParseNode& parse_tree) override
   {
     return SMART_CALL(resolve(parse_tree));
   }
-  virtual ObSelectStmt* get_child_stmt()
+  virtual ObSelectStmt* get_child_stmt() override
   {
     return get_select_stmt();
   }
-  virtual bool is_select_resolver() const
+  virtual bool is_select_resolver() const override
   {
     return true;
   }
@@ -222,7 +222,7 @@ public:
   {
     return in_exists_subquery_;
   }
-  virtual int resolve_column_ref_expr(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr);
+  virtual int resolve_column_ref_expr(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr) override;
   void set_transpose_item(const TransposeItem* transpose_item)
   {
     transpose_item_ = transpose_item;
@@ -274,7 +274,7 @@ protected:
   int resolve_cte_table(const ParseNode& parse_tree, const TableItem* CTE_table_item, TableItem*& table_item);
   int resolve_recursive_cte_table(const ParseNode& parse_tree, TableItem*& table_item);
   int add_parent_cte_table_to_children(ObChildStmtResolver& child_resolver);
-  int add_cte_table_item(TableItem* table_item);
+  int add_cte_table_item(TableItem* table_item) override;
   int resolve_with_clause(const ParseNode* node, bool same_level = false);
   int resolve_from_clause(const ParseNode* node);
   int resolve_field_list(const ParseNode& node);
@@ -336,13 +336,13 @@ protected:
   int resolve_start_with_clause(const ParseNode* node_1, const ParseNode* node_2);
   int resolve_connect_by_clause(const ParseNode* node_1, const ParseNode* node_2);
   int check_correlated_column_ref(const ObSelectStmt& select_stmt, ObRawExpr* expr, bool& correalted_query);
-  virtual int resolve_order_item(const ParseNode& sort_node, OrderItem& order_item);
+  virtual int resolve_order_item(const ParseNode& sort_node, OrderItem& order_item) override;
   virtual int resolve_order_item_by_pos(int64_t pos, OrderItem& order_item, ObSelectStmt* select_stmt);
   virtual int resolve_literal_order_item(
       const ParseNode& sort_node, ObRawExpr* expr, OrderItem& order_item, ObSelectStmt* select_stmt);
   virtual int resolve_aggr_exprs(
-      ObRawExpr*& expr, common::ObIArray<ObAggFunRawExpr*>& aggr_exprs, const bool need_analyze = true);
-  virtual int resolve_win_func_exprs(ObRawExpr*& expr, common::ObIArray<ObWinFunRawExpr*>& win_exprs);
+      ObRawExpr*& expr, common::ObIArray<ObAggFunRawExpr*>& aggr_exprs, const bool need_analyze = true) override;
+  virtual int resolve_win_func_exprs(ObRawExpr*& expr, common::ObIArray<ObWinFunRawExpr*>& win_exprs) override;
   int resolve_column_ref_in_all_namespace(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr);
   /**
    * resolve column real ref expr, search order: alias name first, followed by table column
@@ -361,12 +361,12 @@ protected:
   int resolve_all_generated_table_columns(const TableItem& table_item, common::ObIArray<ColumnItem>* column_items);
   virtual int set_select_item(SelectItem& select_item, bool is_auto_gen);
   int resolve_query_options(const ParseNode* node);
-  virtual int resolve_subquery_info(const common::ObIArray<ObSubQueryInfo>& subquery_info);
-  virtual int resolve_column_ref_for_subquery(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr);
+  virtual int resolve_subquery_info(const common::ObIArray<ObSubQueryInfo>& subquery_info) override;
+  virtual int resolve_column_ref_for_subquery(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr) override;
   inline bool column_need_check_group_by(const ObQualifiedName& q_name) const;
   int check_column_ref_in_group_by_or_field_list(const ObRawExpr* column_ref) const;
   int wrap_alias_column_ref(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr);
-  virtual int check_need_use_sys_tenant(bool& use_sys_tenant) const;
+  virtual int check_need_use_sys_tenant(bool& use_sys_tenant) const override;
   virtual int check_in_sysview(bool& in_sysview) const override;
   int check_group_by();
   int check_order_by();
diff --git a/src/sql/resolver/dml/ob_update_stmt.h b/src/sql/resolver/dml/ob_update_stmt.h
index 171646dee0ae186dad5bac37a6bb8b2ec6bfb81f..18c84ebd8ff4c7e3ac625a3689bad470ab7b97a5 100644
--- a/src/sql/resolver/dml/ob_update_stmt.h
+++ b/src/sql/resolver/dml/ob_update_stmt.h
@@ -71,7 +71,7 @@ public:
 
   // Used to replace all references to from expr in stmt, from from to to expr
   // The search space is only in the expr directly referenced by stmt, and will not recurse into expr
-  virtual int replace_expr_in_stmt(ObRawExpr* from, ObRawExpr* to);
+  virtual int replace_expr_in_stmt(ObRawExpr* from, ObRawExpr* to) override;
   virtual int has_special_expr(const ObExprInfoFlag, bool& has) const override;
   virtual int replace_inner_stmt_expr(
       const common::ObIArray<ObRawExpr*>& other_exprs, const common::ObIArray<ObRawExpr*>& new_exprs) override;
@@ -87,9 +87,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
   {
     return inner_get_relation_exprs(expr_checker);
   }
diff --git a/src/sql/resolver/dml/ob_view_table_resolver.h b/src/sql/resolver/dml/ob_view_table_resolver.h
index 5a83fa9b7514f23ed1baf3897eb6fb86eab3a0f3..75345d3c918c4988058fcd94234820980a77d508 100644
--- a/src/sql/resolver/dml/ob_view_table_resolver.h
+++ b/src/sql/resolver/dml/ob_view_table_resolver.h
@@ -39,7 +39,7 @@ public:
   {
     parent_view_resolver_ = parent_view_resolver;
   }
-  int check_need_use_sys_tenant(bool& use_sys_tenant) const;
+  int check_need_use_sys_tenant(bool& use_sys_tenant) const override;
   virtual int check_in_sysview(bool& in_sysview) const override;
   void set_is_create_view(bool is_create_view)
   {
@@ -64,12 +64,12 @@ public:
 
 protected:
   virtual int do_resolve_set_query(
-      const ParseNode& parse_tree, ObSelectStmt*& child_stmt, const bool is_left_child = false);
-  virtual int expand_view(TableItem& view_item);
-  virtual int resolve_subquery_info(const common::ObIArray<ObSubQueryInfo>& subquery_info);
+      const ParseNode& parse_tree, ObSelectStmt*& child_stmt, const bool is_left_child = false) override;
+  virtual int expand_view(TableItem& view_item) override;
+  virtual int resolve_subquery_info(const common::ObIArray<ObSubQueryInfo>& subquery_info) override;
   int check_view_circular_reference(const TableItem& view_item);
-  virtual int resolve_generate_table(const ParseNode& table_node, const ObString& alias_name, TableItem*& table_item);
-  virtual int set_select_item(SelectItem& select_item, bool is_auto_gen);
+  virtual int resolve_generate_table(const ParseNode& table_node, const ObString& alias_name, TableItem*& table_item) override;
+  virtual int set_select_item(SelectItem& select_item, bool is_auto_gen) override;
   virtual const ObString get_view_db_name() const override
   {
     return view_db_name_;
diff --git a/src/storage/blocksstable/ob_raid_file_system.h b/src/storage/blocksstable/ob_raid_file_system.h
index 9cf08f0fb2253fff243ad478abc4410f23013e95..fc2e37183d4660cee6b0618c9e218cbc730fa70e 100644
--- a/src/storage/blocksstable/ob_raid_file_system.h
+++ b/src/storage/blocksstable/ob_raid_file_system.h
@@ -335,28 +335,28 @@ public:
   ObRaidFileSystem();
   virtual ~ObRaidFileSystem();
 
-  virtual int init(const ObStorageEnv& storage_env, storage::ObPartitionService& partition_service);
-  virtual void destroy();
-  virtual int async_write(const ObStoreFileWriteInfo& write_info, common::ObIOHandle& io_handle);
-  virtual int async_read(const ObStoreFileReadInfo& read_info, common::ObIOHandle& io_handle);
+  virtual int init(const ObStorageEnv& storage_env, storage::ObPartitionService& partition_service) override;
+  virtual void destroy() override;
+  virtual int async_write(const ObStoreFileWriteInfo& write_info, common::ObIOHandle& io_handle) override;
+  virtual int async_read(const ObStoreFileReadInfo& read_info, common::ObIOHandle& io_handle) override;
   virtual int write_server_super_block(const ObServerSuperBlock& super_block) override;
   virtual int read_server_super_block(ObServerSuperBlock& super_block) override;
-  virtual int fsync();
-  virtual int64_t get_total_data_size() const;
-  virtual int init_file_ctx(const ObStoreFileType& file_type, blocksstable::ObStoreFileCtx& file_ctx) const;
+  virtual int fsync() override;
+  virtual int64_t get_total_data_size() const override;
+  virtual int init_file_ctx(const ObStoreFileType& file_type, blocksstable::ObStoreFileCtx& file_ctx) const override;
   virtual bool is_disk_full() const override;
   int init_recover_io_master(const ObMacroBlockCtx& macro_block_ctx, const int64_t aligned_offset,
       const int64_t out_io_buf_size, const ObIODesc& io_desc, const ObBitSet<OB_MAX_DISK_NUMBER>& recover_disk_idx_set,
       ObRaidRecoverIOCallback& callback, ObIOMaster* io_master);
-  virtual int add_disk(const ObString& diskgroup_name, const ObString& disk_path, const ObString& alias_name);
-  virtual int drop_disk(const ObString& diskgroup_name, const ObString& alias_name);
+  virtual int add_disk(const ObString& diskgroup_name, const ObString& disk_path, const ObString& alias_name) override;
+  virtual int drop_disk(const ObString& diskgroup_name, const ObString& alias_name) override;
   int do_rebuild_task();
   virtual int get_disk_status(ObDiskStats& disk_stats) override;
   int64_t get_raid_src_data_num() const;
 
-  virtual int start();
-  virtual void stop();
-  virtual void wait();
+  virtual int start() override;
+  virtual void stop() override;
+  virtual void wait() override;
 
   // used in report bad block.
   virtual int get_macro_block_info(const storage::ObTenantFileKey& file_key, const MacroBlockId& macro_block_id,
diff --git a/src/storage/memtable/ob_memtable_iterator.h b/src/storage/memtable/ob_memtable_iterator.h
index 605e701292483416ec35d72d80e83ed64335b4bc..ef3a55250708031f3edd037f3219059c0c100f85 100644
--- a/src/storage/memtable/ob_memtable_iterator.h
+++ b/src/storage/memtable/ob_memtable_iterator.h
@@ -94,7 +94,7 @@ public:
   void set_rowkey(const common::ObExtStoreRowkey& rowkey);
   virtual int init(const storage::ObTableIterParam& param, storage::ObTableAccessContext& context,
       storage::ObITable* table, const void* query_range) override;
-  virtual int inner_get_next_row(const storage::ObStoreRow*& row);
+  virtual int inner_get_next_row(const storage::ObStoreRow*& row) override;
   virtual void reset();
   virtual void reuse() override
   {
@@ -129,13 +129,13 @@ public:
       storage::ObITable* table, const void* query_range) override;
 
 public:
-  virtual int inner_get_next_row(const storage::ObStoreRow*& row);
+  virtual int inner_get_next_row(const storage::ObStoreRow*& row) override;
   virtual void reset();
   virtual void reuse() override
   {
     reset();
   }
-  virtual int get_gap_end(int64_t& range_idx, const common::ObStoreRowkey*& gap_key, int64_t& gap_size)
+  virtual int get_gap_end(int64_t& range_idx, const common::ObStoreRowkey*& gap_key, int64_t& gap_size) override
   {
     int ret = common::OB_SUCCESS;
     range_idx = 0;
@@ -145,7 +145,7 @@ public:
     }
     return ret;
   }
-  virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key);
+  virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key) override;
   ObIMemtable* get_memtable()
   {
     return memtable_;
@@ -160,7 +160,7 @@ public:
                ? 0
                : context_->store_ctx_->mem_ctx_->get_read_snapshot();
   }
-  uint8_t get_iter_flag()
+  uint8_t get_iter_flag() override
   {
     return iter_flag_;
   }
@@ -210,7 +210,7 @@ public:
       storage::ObITable* table, const void* query_range) override;
 
 public:
-  virtual int inner_get_next_row(const storage::ObStoreRow*& row);
+  virtual int inner_get_next_row(const storage::ObStoreRow*& row) override;
   virtual void reset();
   virtual void reuse() override
   {
@@ -248,14 +248,14 @@ public:
 public:
   int init(const storage::ObTableIterParam& param, storage::ObTableAccessContext& context, storage::ObITable* table,
       const void* query_range) override;
-  virtual int inner_get_next_row(const storage::ObStoreRow*& row);
-  virtual void reset();
+  virtual int inner_get_next_row(const storage::ObStoreRow*& row) override;
+  virtual void reset() override;
   virtual void reuse() override
   {
     reset();
   }
-  virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key);
-  virtual int get_gap_end(int64_t& range_idx, const common::ObStoreRowkey*& gap_key, int64_t& gap_size)
+  virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key) override;
+  virtual int get_gap_end(int64_t& range_idx, const common::ObStoreRowkey*& gap_key, int64_t& gap_size) override
   {
     int ret = common::OB_SUCCESS;
     if (OB_FAIL(ObMemtableScanIterator::get_gap_end(range_idx, gap_key, gap_size))) {
@@ -293,7 +293,7 @@ public:
       storage::ObITable* table, const void* query_range) override;
 
 public:
-  virtual int inner_get_next_row(const storage::ObStoreRow*& row);
+  virtual int inner_get_next_row(const storage::ObStoreRow*& row) override;
   virtual void reset();
   virtual void reuse() override
   {
diff --git a/src/storage/ob_build_index_scheduler.h b/src/storage/ob_build_index_scheduler.h
index 56da0e58e35cc7ababeef92d4357b43165ae3d44..a9fb10ab8a49d6cc4048de4ac4bbad26ad959234 100644
--- a/src/storage/ob_build_index_scheduler.h
+++ b/src/storage/ob_build_index_scheduler.h
@@ -63,10 +63,10 @@ public:
   ObTenantDDLCheckSchemaTask();
   virtual ~ObTenantDDLCheckSchemaTask();
   int init(const uint64_t tenant_id, const int64_t base_version, const int64_t refreshed_version);
-  virtual bool operator==(const ObIDDLTask& other) const;
-  virtual int64_t hash() const;
-  virtual int process();
-  virtual int64_t get_deep_copy_size() const
+  virtual bool operator==(const ObIDDLTask& other) const override;
+  virtual int64_t hash() const override;
+  virtual int process() override;
+  virtual int64_t get_deep_copy_size() const override
   {
     return sizeof(*this);
   }
@@ -107,10 +107,10 @@ public:
   virtual ~ObBuildIndexScheduleTask();
   int init(const common::ObPartitionKey& pkey, const uint64_t index_id, const int64_t schema_version,
       const bool is_unique_index);
-  virtual bool operator==(const ObIDDLTask& other) const;
-  virtual int64_t hash() const;
-  virtual int process();
-  virtual int64_t get_deep_copy_size() const
+  virtual bool operator==(const ObIDDLTask& other) const override;
+  virtual int64_t hash() const override;
+  virtual int process() override;
+  virtual int64_t get_deep_copy_size() const override
   {
     return sizeof(*this);
   }
diff --git a/src/storage/ob_build_index_task.h b/src/storage/ob_build_index_task.h
index 48539469977a5f022b8eb2e0345c2b94f657351b..6974cc34f23e06b3d87c369ce6e495881abae735 100644
--- a/src/storage/ob_build_index_task.h
+++ b/src/storage/ob_build_index_task.h
@@ -36,8 +36,8 @@ public:
   ObBuildIndexDag();
   virtual ~ObBuildIndexDag();
   int init(const ObPartitionKey& pkey, storage::ObPartitionService* partition_service);
-  virtual int64_t hash() const;
-  virtual bool operator==(const share::ObIDag& other) const;
+  virtual int64_t hash() const override;
+  virtual bool operator==(const share::ObIDag& other) const override;
   virtual int prepare();
   virtual int clean_up();
   int get_partition_storage(ObPartitionStorage*& storage);
@@ -67,7 +67,7 @@ public:
   {
     return pkey_.get_tenant_id();
   }
-  virtual int fill_comment(char* buf, const int64_t buf_len) const;
+  virtual int fill_comment(char* buf, const int64_t buf_len) const override;
   virtual int64_t get_compat_mode() const override
   {
     return static_cast<int64_t>(compat_mode_);
@@ -334,8 +334,8 @@ public:
   int alloc_local_index_task_callback(ObLocalUniqueIndexCallback*& callback);
   int alloc_global_index_task_callback(
       const ObPartitionKey& pkey, const uint64_t index_id, ObGlobalUniqueIndexCallback*& callback);
-  virtual int64_t hash() const;
-  virtual bool operator==(const share::ObIDag& other) const;
+  virtual int64_t hash() const override;
+  virtual bool operator==(const share::ObIDag& other) const override;
   virtual int64_t get_tenant_id() const override
   {
     return pkey_.get_tenant_id();
diff --git a/src/storage/ob_multiple_get_merge.h b/src/storage/ob_multiple_get_merge.h
index 844efbc06b83c23496cb2b975ae659385d64cd65..864b9cf617ed8054a83a6ef197870ca7276598ca 100644
--- a/src/storage/ob_multiple_get_merge.h
+++ b/src/storage/ob_multiple_get_merge.h
@@ -66,7 +66,7 @@ protected:
   virtual int prepare() override;
   virtual int calc_scan_range() override;
   virtual int construct_iters() override;
-  virtual int inner_get_next_row(ObStoreRow& row);
+  virtual int inner_get_next_row(ObStoreRow& row) override;
   virtual void collect_merge_stat(ObTableStoreStat& stat) const override;
   virtual int skip_to_range(const int64_t range_idx) override;
 
diff --git a/src/storage/ob_multiple_merge.h b/src/storage/ob_multiple_merge.h
index c314f7fee8f1fbdcc38fe86272ece6dae4042917..12f8cdc2c77aa8d2e8cc49978d802478f83aee0b 100644
--- a/src/storage/ob_multiple_merge.h
+++ b/src/storage/ob_multiple_merge.h
@@ -62,7 +62,7 @@ public:
   }
   virtual int switch_iterator(const int64_t range_array_idx) override;
   int refresh_table_on_demand();
-  virtual int release_table_ref();
+  virtual int release_table_ref() override;
 
 protected:
   int open();
diff --git a/src/storage/ob_multiple_multi_scan_merge.h b/src/storage/ob_multiple_multi_scan_merge.h
index 46b4afc449dcb92bf98bd4eddabf8e0e95941469..a3e4ad3207740fc49c676daefb3662bb1ac4bb19 100644
--- a/src/storage/ob_multiple_multi_scan_merge.h
+++ b/src/storage/ob_multiple_multi_scan_merge.h
@@ -23,7 +23,7 @@ public:
 
 public:
   int open(const common::ObIArray<common::ObExtStoreRange>& ranges);
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
   static int estimate_row_count(const common::ObQueryFlag query_flag, const uint64_t table_id,
       const common::ObIArray<common::ObExtStoreRange>& ranges, const common::ObIArray<ObITable*>& tables,
@@ -32,7 +32,7 @@ public:
 protected:
   virtual int calc_scan_range() override;
   virtual int construct_iters() override;
-  virtual int inner_get_next_row(ObStoreRow& row);
+  virtual int inner_get_next_row(ObStoreRow& row) override;
   virtual int prepare() override;
   virtual int is_range_valid() const override;
   virtual void collect_merge_stat(ObTableStoreStat& stat) const override;
diff --git a/src/storage/ob_partition_group.h b/src/storage/ob_partition_group.h
index a5f39b859e1b9c82a32b8a387a6fdfe4fec8f3d7..fb7ea73aca144d123c2dd1162dc9e66386a38b07 100644
--- a/src/storage/ob_partition_group.h
+++ b/src/storage/ob_partition_group.h
@@ -63,21 +63,21 @@ public:
       share::schema::ObMultiVersionSchemaService* schema_service, transaction::ObTransService* txs,
       replayengine::ObILogReplayEngine* rp_eg, ObPartitionService* ps, ObPartitionGroupIndex* pg_index,
       ObPGPartitionMap* pg_partition_map) override;
-  virtual void destroy();
+  virtual void destroy() override;
   virtual void clear() override;
 
-  virtual const clog::ObIPartitionLogService* get_log_service() const;
-  virtual clog::ObIPartitionLogService* get_log_service();
+  virtual const clog::ObIPartitionLogService* get_log_service() const override;
+  virtual clog::ObIPartitionLogService* get_log_service() override;
   virtual ObIPartitionComponentFactory* get_cp_fty()
   {
     return cp_fty_;
   }
 
-  virtual ObPGStorage& get_pg_storage()
+  virtual ObPGStorage& get_pg_storage() override
   {
     return pg_storage_;
   }
-  virtual ObPartitionService* get_partition_service();
+  virtual ObPartitionService* get_partition_service() override;
   virtual ObPartitionGroupIndex* get_pg_index() override
   {
     return pg_index_;
@@ -86,37 +86,39 @@ public:
   {
     return pg_partition_map_;
   };
-  virtual transaction::ObTransService* get_trans_service();
-  virtual const common::ObPartitionKey& get_partition_key() const;
-  virtual int get_pg_partition(const common::ObPartitionKey& pkey, ObPGPartitionGuard& guard);
-
-  virtual int set_valid();
-  virtual void set_invalid();
-  virtual bool is_valid() const;
-  virtual bool is_pg() const
+  virtual transaction::ObTransService* get_trans_service() override;
+  virtual const common::ObPartitionKey& get_partition_key() const override;
+  virtual int get_pg_partition(const common::ObPartitionKey& pkey, ObPGPartitionGuard& guard) override;
+
+  virtual int set_valid() override;
+  virtual void set_invalid() override;
+  virtual bool is_valid() const override;
+  virtual bool is_pg() const override
   {
     return pkey_.is_pg();
   }
 
-  virtual int table_scan(ObTableScanParam& param, common::ObNewRowIterator*& result);
+  virtual int table_scan(ObTableScanParam& param, common::ObNewRowIterator*& result) override;
   virtual int table_scan(ObTableScanParam& param, common::ObNewIterIterator*& result) override;
   virtual int join_mv_scan(ObTableScanParam& left_param, ObTableScanParam& right_param,
       ObIPartitionGroup& right_partition, common::ObNewRowIterator*& result) override;
   virtual int delete_rows(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
-      const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter, int64_t& affected_rows);
+      const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter,
+      int64_t& affected_rows) override;
   virtual int delete_row(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& column_ids, const common::ObNewRow& row) override;
   virtual int put_rows(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter,
       int64_t& affected_rows) override;
   virtual int insert_rows(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
-      const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter, int64_t& affected_rows);
+      const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter,
+      int64_t& affected_rows) override;
   virtual int insert_row(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& column_ids, const common::ObNewRow& row) override;
   virtual int insert_row(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& column_ids, const common::ObIArray<uint64_t>& duplicated_column_ids,
       const common::ObNewRow& row, const ObInsertFlag flag, int64_t& affected_rows,
-      common::ObNewRowIterator*& duplicated_rows);
+      common::ObNewRowIterator*& duplicated_rows) override;
   // Used to check whether the specified row conflicts in the storage
   // @in_column_ids is used to specify the column of the row to be checked.
   // Rowkey must be first and local unique index must be included.
@@ -126,11 +128,11 @@ public:
   // to the number of rows to be checked
   virtual int fetch_conflict_rows(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& in_column_ids, const common::ObIArray<uint64_t>& out_column_ids,
-      common::ObNewRowIterator& check_row_iter, common::ObIArray<common::ObNewRowIterator*>& dup_row_iters);
-  virtual int revert_insert_iter(const common::ObPartitionKey& pkey, common::ObNewRowIterator* iter);
+      common::ObNewRowIterator& check_row_iter, common::ObIArray<common::ObNewRowIterator*>& dup_row_iters) override;
+  virtual int revert_insert_iter(const common::ObPartitionKey& pkey, common::ObNewRowIterator* iter) override;
   virtual int update_rows(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& column_ids, const common::ObIArray<uint64_t>& updated_column_ids,
-      common::ObNewRowIterator* row_iter, int64_t& affected_rows);
+      common::ObNewRowIterator* row_iter, int64_t& affected_rows) override;
   virtual int update_row(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
       const common::ObIArray<uint64_t>& column_ids, const common::ObIArray<uint64_t>& updated_column_ids,
       const common::ObNewRow& old_row, const common::ObNewRow& new_row) override;
@@ -139,26 +141,26 @@ public:
   virtual int lock_rows(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const int64_t abs_lock_timeout,
       const common::ObNewRow& row, ObLockFlag lock_flag) override;
 
-  virtual int get_role(common::ObRole& role) const;
-  virtual int get_role_unsafe(common::ObRole& role) const;
-  virtual int get_leader_curr_member_list(common::ObMemberList& member_list) const;
-  virtual int get_leader(common::ObAddr& leader) const;
-  virtual int get_curr_member_list(common::ObMemberList& member_list) const;
-  virtual int get_curr_member_list_for_report(common::ObMemberList& member_list) const;
+  virtual int get_role(common::ObRole& role) const override;
+  virtual int get_role_unsafe(common::ObRole& role) const override;
+  virtual int get_leader_curr_member_list(common::ObMemberList& member_list) const override;
+  virtual int get_leader(common::ObAddr& leader) const override;
+  virtual int get_curr_member_list(common::ObMemberList& member_list) const override;
+  virtual int get_curr_member_list_for_report(common::ObMemberList& member_list) const override;
   virtual int get_curr_leader_and_memberlist(common::ObAddr& leader, common::ObRole& role,
-      common::ObMemberList& curr_member_list, common::ObChildReplicaList& children_list) const;
-  virtual int get_dst_leader_candidate(common::ObMemberList& member_list) const;
-  virtual int get_log_archive_status(clog::ObPGLogArchiveStatus& status) const;
-  virtual int change_leader(const common::ObAddr& leader);
+      common::ObMemberList& curr_member_list, common::ObChildReplicaList& children_list) const override;
+  virtual int get_dst_leader_candidate(common::ObMemberList& member_list) const override;
+  virtual int get_log_archive_status(clog::ObPGLogArchiveStatus& status) const override;
+  virtual int change_leader(const common::ObAddr& leader) override;
   virtual int leader_takeover() override;
-  virtual int leader_revoke();
-  virtual int leader_active();
-  virtual ObReplayStatus* get_replay_status();
+  virtual int leader_revoke() override;
+  virtual int leader_active() override;
+  virtual ObReplayStatus* get_replay_status() 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);
+  virtual int serialize(ObArenaAllocator& allocator, char*& new_buf, int64_t& serialize_size) override;
 
   // read ssstore objects from data file to construct partition storage's version tree.
-  virtual int deserialize(const char* buf, const int64_t buf_len, int64_t& pos);
+  virtual int deserialize(const char* buf, const int64_t buf_len, int64_t& pos) override;
 
   virtual int report_clog_history_online() override;
   virtual int report_clog_history_offline() override;
@@ -170,96 +172,97 @@ public:
   virtual int schema_drop(const bool for_replay, const uint64_t log_id, const bool is_physical_drop) override;
 
   // get create timestamp
-  virtual int get_create_ts(int64_t& create_ts);
+  virtual int get_create_ts(int64_t& create_ts) override;
 
   // role change status
-  virtual void replay_status_revoke();
+  virtual void replay_status_revoke() override;
 
-  virtual int get_replica_state(ObPartitionReplicaState& state);
+  virtual int get_replica_state(ObPartitionReplicaState& state) override;
 
-  virtual bool is_removed() const;
-  virtual int check_is_in_member_list(bool& is_in_member_list) const;
-  virtual int offline_itself(const bool is_physical_drop);
+  virtual bool is_removed() const override;
+  virtual int check_is_in_member_list(bool& is_in_member_list) const override;
+  virtual int offline_itself(const bool is_physical_drop) override;
   virtual int submit_add_partition_to_pg_log(const obrpc::ObCreatePartitionArg& arg, ObPartitionService* ps,
-      uint64_t& log_id, int64_t& log_timestamp, ObAddPartitionToPGLogCb*& out_cb);
-  virtual int submit_remove_partition_from_pg_log(const ObPartitionKey& pkey);
+      uint64_t& log_id, int64_t& log_timestamp, ObAddPartitionToPGLogCb*& out_cb) override;
+  virtual int submit_remove_partition_from_pg_log(const ObPartitionKey& pkey) override;
   virtual int submit_partition_schema_change_log(const common::ObPartitionKey& pkey, const int64_t schema_version,
       const uint64_t index_id, ObPartitionService* ps, uint64_t& log_id, int64_t& log_ts,
-      ObSchemaChangeClogCb*& out_cb);
+      ObSchemaChangeClogCb*& out_cb) override;
   virtual int remove_partition_from_pg(
-      const bool for_replay, const ObPartitionKey& pkey, const bool write_slog_trans, const uint64_t log_id);
+      const bool for_replay, const ObPartitionKey& pkey, const bool write_slog_trans, const uint64_t log_id) override;
 
   virtual int replay_partition_meta_log(
       const ObStorageLogType log_type, const int64_t log_id, const char* buf, const int64_t size) override;
-  virtual int set_wait_split();
-  virtual int save_split_state(const bool write_slog);
-  virtual int restore_split_state(const int state);
-  virtual int restore_split_info(const ObPartitionSplitInfo& split_info);
+  virtual int set_wait_split() override;
+  virtual int save_split_state(const bool write_slog) override;
+  virtual int restore_split_state(const int state) override;
+  virtual int restore_split_info(const ObPartitionSplitInfo& split_info) override;
   virtual int replay_split_source_log(
-      const ObPartitionSplitSourceLog& log, const uint64_t log_id, const int64_t log_ts);
-  virtual int replay_split_dest_log(const ObPartitionSplitDestLog& log);
-  virtual int sync_split_source_log_success(const int64_t log_id, const int64_t log_ts);
-  virtual int sync_split_dest_log_success();
+      const ObPartitionSplitSourceLog& log, const uint64_t log_id, const int64_t log_ts) override;
+  virtual int replay_split_dest_log(const ObPartitionSplitDestLog& log) override;
+  virtual int sync_split_source_log_success(const int64_t log_id, const int64_t log_ts) override;
+  virtual int sync_split_dest_log_success() override;
   virtual int prepare_splitting(
-      const ObPartitionSplitInfo& split_info, const common::ObMemberList& mlist, const common::ObAddr& leader);
+      const ObPartitionSplitInfo& split_info, const common::ObMemberList& mlist, const common::ObAddr& leader) override;
   virtual int split_source_partition(const int64_t schema_version, const share::ObSplitPartitionPair& info,
-      enum share::ObSplitProgress& partition_progress);
-  virtual int split_dest_partition(const ObPartitionSplitInfo& split_info, enum share::ObSplitProgress& progress);
+      enum share::ObSplitProgress& partition_progress) override;
+  virtual int split_dest_partition(
+      const ObPartitionSplitInfo& split_info, enum share::ObSplitProgress& progress) override;
   virtual int push_reference_tables(
-      const common::ObIArray<common::ObPartitionKey>& dest_array, const int64_t split_version);
-  virtual int replay_split_state_slog(const ObSplitPartitionStateLogEntry& log_entry);
-  virtual int replay_split_info_slog(const ObSplitPartitionInfoLogEntry& log_entry);
+      const common::ObIArray<common::ObPartitionKey>& dest_array, const int64_t split_version) override;
+  virtual int replay_split_state_slog(const ObSplitPartitionStateLogEntry& log_entry) override;
+  virtual int replay_split_info_slog(const ObSplitPartitionInfoLogEntry& log_entry) override;
   virtual int set_dest_partition_split_progress(
-      const int64_t schema_version, const common::ObPartitionKey& pkey, const int progress);
-  virtual int get_all_table_ids(const ObPartitionKey& pkey, common::ObIArray<uint64_t>& index_tables);
-  virtual int get_reference_tables(const ObPartitionKey& pkey, const int64_t index_id, ObTablesHandle& handle);
-  virtual int get_reference_memtables(ObTablesHandle& handle);
-  virtual int set_reference_tables(const ObPartitionKey& pkey, const int64_t index_id, ObTablesHandle& handle);
-  virtual int set_split_version(const int64_t split_version);
-  virtual int check_can_migrate(bool& can_migrate);
-  virtual bool is_splitting() const;
-  virtual bool is_split_source_partition() const;
-  virtual bool is_in_dest_split() const;
-  virtual bool is_dest_logical_split_finish() const;
-  virtual int check_split_state() const;
-  virtual int get_split_progress(const int64_t schema_version, int& progress);
-  virtual int set_split_progress(const common::ObAddr& replica, const int progress);
-  virtual int block_partition_split_by_mc();
-  virtual int unblock_partition_split_by_mc();
+      const int64_t schema_version, const common::ObPartitionKey& pkey, const int progress) override;
+  virtual int get_all_table_ids(const ObPartitionKey& pkey, common::ObIArray<uint64_t>& index_tables) override;
+  virtual int get_reference_tables(const ObPartitionKey& pkey, const int64_t index_id, ObTablesHandle& handle) override;
+  virtual int get_reference_memtables(ObTablesHandle& handle) override;
+  virtual int set_reference_tables(const ObPartitionKey& pkey, const int64_t index_id, ObTablesHandle& handle) override;
+  virtual int set_split_version(const int64_t split_version) override;
+  virtual int check_can_migrate(bool& can_migrate) override;
+  virtual bool is_splitting() const override;
+  virtual bool is_split_source_partition() const override;
+  virtual bool is_in_dest_split() const override;
+  virtual bool is_dest_logical_split_finish() const override;
+  virtual int check_split_state() const override;
+  virtual int get_split_progress(const int64_t schema_version, int& progress) override;
+  virtual int set_split_progress(const common::ObAddr& replica, const int progress) override;
+  virtual int block_partition_split_by_mc() override;
+  virtual int unblock_partition_split_by_mc() override;
   virtual int64_t get_freeze_snapshot_ts() const override;
-  virtual ObPartitionState get_partition_state() const;
-  virtual int switch_partition_state(const ObPartitionState state);
+  virtual ObPartitionState get_partition_state() const override;
+  virtual int switch_partition_state(const ObPartitionState state) override;
 
   virtual int try_switch_partition_state(const ObPartitionState state) override;
   virtual int get_latest_schema_version(share::schema::ObMultiVersionSchemaService* schema_service,
-      const common::ObPartitionKey& pkey, int64_t& latest_schema_version);
-  virtual int check_schema_version(share::schema::ObMultiVersionSchemaService* schema_service);
-  virtual int set_base_schema_version(int64_t base_schema_version);
-  virtual int do_warm_up_request(const ObIWarmUpRequest* request);
-  virtual int check_can_do_merge(bool& can_merge, bool& need_merge);
-  virtual int set_replica_type(const common::ObReplicaType& replica_type, const bool write_redo_log);
-  virtual common::ObReplicaType get_replica_type() const;
+      const common::ObPartitionKey& pkey, int64_t& latest_schema_version) override;
+  virtual int check_schema_version(share::schema::ObMultiVersionSchemaService* schema_service) override;
+  virtual int set_base_schema_version(int64_t base_schema_version) override;
+  virtual int do_warm_up_request(const ObIWarmUpRequest* request) override;
+  virtual int check_can_do_merge(bool& can_merge, bool& need_merge) override;
+  virtual int set_replica_type(const common::ObReplicaType& replica_type, const bool write_redo_log) override;
+  virtual common::ObReplicaType get_replica_type() const override;
   virtual common::ObReplicaProperty get_replica_property() const override;
   virtual int generate_weak_read_timestamp(const int64_t max_stale_time, int64_t& timestamp) override;
   virtual int do_partition_loop_work() override;
-  virtual int get_weak_read_timestamp(int64_t& timestamp);
-  virtual int update_last_checkpoint(const int64_t checkpoint);
-  virtual int set_replay_checkpoint(const int64_t checkpoint);
-  virtual int get_replay_checkpoint(int64_t& checkpoint);
-  virtual int64_t get_cur_min_log_service_ts();
-  virtual int64_t get_cur_min_trans_service_ts();
-  virtual int64_t get_cur_min_replay_engine_ts();
-  virtual void set_migrating_flag(const bool flag)
+  virtual int get_weak_read_timestamp(int64_t& timestamp) override;
+  virtual int update_last_checkpoint(const int64_t checkpoint) override;
+  virtual int set_replay_checkpoint(const int64_t checkpoint) override;
+  virtual int get_replay_checkpoint(int64_t& checkpoint) override;
+  virtual int64_t get_cur_min_log_service_ts() override;
+  virtual int64_t get_cur_min_trans_service_ts() override;
+  virtual int64_t get_cur_min_replay_engine_ts() override;
+  virtual void set_migrating_flag(const bool flag) override
   {
     partition_loop_worker_.set_migrating_flag(flag);
   }
-  virtual bool get_migrating_flag() const
+  virtual bool get_migrating_flag() const override
   {
     return partition_loop_worker_.get_migrating_flag();
   }
 
-  virtual int need_minor_freeze(const uint64_t& log_id, bool& need_freeze);
-  virtual int set_emergency_release();
+  virtual int need_minor_freeze(const uint64_t& log_id, bool& need_freeze) override;
+  virtual int set_emergency_release() override;
 
   virtual int freeze(const bool emergency, const bool force, int64_t& freeze_snapshot) override;
   // Mark dirty of transactions on the terminated memtable
@@ -268,7 +271,7 @@ public:
   virtual int get_curr_storage_info_for_migrate(const bool use_slave_safe_read_ts,
       const common::ObReplicaType replica_type, const int64_t src_cluster_id, ObSavedStorageInfoV2& info) override;
 
-  virtual int check_is_from_restore(bool& is_from_restore) const;
+  virtual int check_is_from_restore(bool& is_from_restore) const override;
   virtual int get_all_saved_info(ObSavedStorageInfoV2& info) const override;
   virtual int get_saved_clog_info(common::ObBaseStorageInfo& clog_info) const override;
   virtual int get_saved_data_info(ObDataStorageInfo& data_info) const override;
@@ -278,26 +281,26 @@ public:
       const share::ObBuildIndexAppendLocalDataParam& param, common::ObNewRowIterator& iter) override;
   virtual int append_sstable(const common::ObPartitionKey& pkey, const share::ObBuildIndexAppendSSTableParam& param,
       common::ObNewRowIterator& iter) override;
-  virtual const ObPartitionSplitInfo& get_split_info()
+  virtual const ObPartitionSplitInfo& get_split_info() override
   {
     return split_info_;
   }
-  virtual int check_cur_partition_split(bool& is_split_partition);
-  virtual int get_trans_split_info(transaction::ObTransSplitInfo& split_info);
+  virtual int check_cur_partition_split(bool& is_split_partition) override;
+  virtual int get_trans_split_info(transaction::ObTransSplitInfo& split_info) override;
   virtual int check_single_replica_major_sstable_exist(
       const ObPartitionKey& pkey, const uint64_t index_table_id) override;
-  virtual int get_max_decided_trans_version(int64_t& max_decided_trans_version) const;
+  virtual int get_max_decided_trans_version(int64_t& max_decided_trans_version) const override;
 
   int create_memtable(const bool in_slog_trans = false, const bool is_replay = false,
       const bool ignore_memstore_percent = false) override;
-  virtual int get_table_stat(const common::ObPartitionKey& pkey, common::ObTableStat& stat);
+  virtual int get_table_stat(const common::ObPartitionKey& pkey, common::ObTableStat& stat) override;
   // The following two interface are used by ObGarbageCollector
-  virtual int allow_gc(bool& allow_gc);
-  virtual int gc_check_valid_member(const bool is_valid, const int64_t gc_seq, bool& need_gc);
-  virtual bool check_pg_partition_offline(const ObPartitionKey& pkey);
-  virtual int check_offline_log_archived(
-      const ObPartitionKey& pkey, const int64_t incarnation, const int64_t archive_round, bool& has_archived) const;
-  virtual int get_leader_epoch(int64_t& leader_epoch) const;
+  virtual int allow_gc(bool& allow_gc) override;
+  virtual int gc_check_valid_member(const bool is_valid, const int64_t gc_seq, bool& need_gc) override;
+  virtual bool check_pg_partition_offline(const ObPartitionKey& pkey) override;
+  virtual int check_offline_log_archived(const ObPartitionKey& pkey, const int64_t incarnation,
+      const int64_t archive_round, bool& has_archived) const override;
+  virtual int get_leader_epoch(int64_t& leader_epoch) const override;
   virtual int get_replica_status(share::ObReplicaStatus& status) override;
   virtual int is_replica_need_gc(bool& is_offline) override;
   virtual int set_storage_info(const ObSavedStorageInfoV2& info) override;
@@ -306,11 +309,11 @@ public:
   virtual int fill_replica(share::ObPartitionReplica& replica) override;
   virtual int get_merge_priority_info(memtable::ObMergePriorityInfo& merge_priority_info) const override;
   virtual int64_t get_gc_schema_drop_ts() override;
-  virtual void set_need_rebuild()
+  virtual void set_need_rebuild() override
   {
     migrate_retry_flag_ = NEED_REBUILD;
   }
-  virtual bool is_need_rebuild() const
+  virtual bool is_need_rebuild() const override
   {
     return (NEED_REBUILD == migrate_retry_flag_);
   }
@@ -318,27 +321,27 @@ public:
   {
     migrate_retry_flag_ = NEED_STANDBY_RESTORE;
   }
-  virtual bool is_need_standby_restore() const
+  virtual bool is_need_standby_restore() const override
   {
     return (NEED_STANDBY_RESTORE == migrate_retry_flag_);
   }
-  virtual void reset_migrate_retry_flag()
+  virtual void reset_migrate_retry_flag() override
   {
     migrate_retry_flag_ = NO_NEED_RETRY;
   }
-  virtual void set_need_gc()
+  virtual void set_need_gc() override
   {
     ATOMIC_STORE(&need_gc_, true);
   }
-  virtual bool is_need_gc() const
+  virtual bool is_need_gc() const override
   {
     return ATOMIC_LOAD(&need_gc_);
   }
-  virtual uint64_t get_offline_log_id() const
+  virtual uint64_t get_offline_log_id() const override
   {
     return ATOMIC_LOAD(&offline_log_id_);
   }
-  virtual int set_offline_log_id(const uint64_t log_id);
+  virtual int set_offline_log_id(const uint64_t log_id) override;
   virtual int retire_warmup_store(const bool is_disk_full) override;
   int has_active_memtable(bool& found);
   virtual int enable_write_log(const bool is_replay_old) override;
@@ -347,7 +350,7 @@ public:
   virtual int check_dirty_txn(
       const int64_t min_log_ts, const int64_t max_log_ts, int64_t& freeze_ts, bool& is_dirty) override;
   // Create Partition Group
-  int create_partition_group(const ObCreatePGParam& param);
+  int create_partition_group(const ObCreatePGParam& param) override;
   int create_pg_partition(const common::ObPartitionKey& pkey, const int64_t multi_version_start,
       const uint64_t data_table_id, const obrpc::ObCreatePartitionArg& arg, const bool in_slog_trans,
       const bool is_replay, const uint64_t log_id, ObTablesHandle& sstables_handle) override;
@@ -359,8 +362,8 @@ public:
   int check_release_memtable();
   virtual int add_sstable_for_merge(const ObPartitionKey& pkey, storage::ObSSTable* sstable,
       const int64_t max_kept_major_version_number, ObIPartitionReport& report,
-      ObSSTable* complement_minor_sstable = nullptr);
-  virtual int check_replica_ready_for_bounded_staleness_read(const int64_t snapshot_version);
+      ObSSTable* complement_minor_sstable = nullptr) override;
+  virtual int check_replica_ready_for_bounded_staleness_read(const int64_t snapshot_version) override;
   virtual bool is_replica_using_remote_memstore() const
   {
     return pg_storage_.is_replica_with_remote_memstore() && F_WORKING == get_partition_state();
@@ -390,14 +393,14 @@ public:
   virtual int get_checkpoint_info(common::ObArenaAllocator& allocator, ObPGCheckpointInfo& pg_checkpoint_info) override;
   virtual int acquire_sstable(const ObITable::TableKey& table_key, ObTableHandle& table_handle) override;
   virtual int recycle_unused_sstables(const int64_t max_recycle_cnt, int64_t& recycled_cnt) override;
-  virtual int recycle_sstable(const ObITable::TableKey &table_key) override;
+  virtual int recycle_sstable(const ObITable::TableKey& table_key) override;
   virtual int check_can_free(bool& can_free) override;
 
-  virtual bool need_replay_redo() const;
-  virtual int try_clear_split_info();
-  virtual int check_complete(bool& is_complete);
+  virtual bool need_replay_redo() const override;
+  virtual int try_clear_split_info() override;
+  virtual int check_complete(bool& is_complete) override;
   virtual int try_update_clog_member_list(const uint64_t ms_log_id, const int64_t mc_timestamp,
-      const int64_t replica_num, const ObMemberList& mlist, const common::ObProposalID& ms_proposal_id);
+      const int64_t replica_num, const ObMemberList& mlist, const common::ObProposalID& ms_proposal_id) override;
   virtual int check_physical_flashback_succ(const obrpc::ObCheckPhysicalFlashbackArg& arg, const int64_t max_version,
       obrpc::ObPhysicalFlashbackResultArg& result) override;
   // Check if weak read is enabled.
@@ -409,10 +412,11 @@ public:
   {
     return &partition_loop_worker_;
   }
-  virtual int save_split_info(const ObPartitionSplitInfo& split_info);
-  virtual int save_split_state(const int64_t split_state);
-  virtual int shutdown(const int64_t snapshot_version, const uint64_t replay_log_id, const int64_t schema_version);
-  virtual int physical_flashback(const int64_t flashback_scn);
+  virtual int save_split_info(const ObPartitionSplitInfo& split_info) override;
+  virtual int save_split_state(const int64_t split_state) override;
+  virtual int shutdown(
+      const int64_t snapshot_version, const uint64_t replay_log_id, const int64_t schema_version) override;
+  virtual int physical_flashback(const int64_t flashback_scn) override;
   virtual int set_meta_block_list(const common::ObIArray<blocksstable::MacroBlockId>& meta_block_list) override;
   virtual int get_meta_block_list(common::ObIArray<blocksstable::MacroBlockId>& meta_block_list) const override;
   virtual int get_all_tables(ObTablesHandle& tables_handle) override;
@@ -421,14 +425,14 @@ public:
 
   int check_can_physical_flashback(const int64_t flashback_scn);
 
-  virtual int clear_trans_after_restore_log(const uint64_t last_restore_log_id, const int64_t last_restore_log_ts);
-  virtual int reset_for_replay();
+  virtual int clear_trans_after_restore_log(const uint64_t last_restore_log_id, const int64_t last_restore_log_ts) override;
+  virtual int reset_for_replay() override;
 
-  virtual int inc_pending_batch_commit_count(memtable::ObMemtableCtx& mt_ctx, const int64_t log_ts);
-  virtual int inc_pending_elr_count(memtable::ObMemtableCtx& mt_ctx, const int64_t log_ts);
+  virtual int inc_pending_batch_commit_count(memtable::ObMemtableCtx& mt_ctx, const int64_t log_ts) override;
+  virtual int inc_pending_elr_count(memtable::ObMemtableCtx& mt_ctx, const int64_t log_ts) override;
 
-  virtual int register_txs_change_leader(const common::ObAddr& server, ObTsWindows& changing_leader_windows);
-  virtual int check_physical_split(bool& finished);
+  virtual int register_txs_change_leader(const common::ObAddr& server, ObTsWindows& changing_leader_windows) override;
+  virtual int check_physical_split(bool& finished) override;
   TO_STRING_KV(K_(pkey), K_(replay_status), K_(partition_state));
 
 private:
diff --git a/src/storage/ob_partition_migrator.h b/src/storage/ob_partition_migrator.h
index 0431820ae93b34f288458f9c966190f65fe64b7d..5967e896f289adb1fc8d5df43edfbfa776635757 100644
--- a/src/storage/ob_partition_migrator.h
+++ b/src/storage/ob_partition_migrator.h
@@ -1020,7 +1020,7 @@ class ObMigrateCopyPhysicalTask : public share::ObITask {
 public:
   ObMigrateCopyPhysicalTask();
   virtual ~ObMigrateCopyPhysicalTask();
-  int generate_next_task(ObITask*& next_task);
+  int generate_next_task(ObITask*& next_task) override;
   int init(const int64_t task_idx, ObMigratePhysicalSSTableCtx& sstable_ctx, ObMigrateCtx& ctx);
   virtual int process() override;
 
diff --git a/src/storage/ob_single_merge.h b/src/storage/ob_single_merge.h
index fb7f183060832e7d0400917bd33f6190f1d2898e..c4bc216a37adef71e62323823814569e3f5722e2 100644
--- a/src/storage/ob_single_merge.h
+++ b/src/storage/ob_single_merge.h
@@ -24,7 +24,7 @@ public:
   ObSingleMerge();
   virtual ~ObSingleMerge();
   int open(const common::ObExtStoreRowkey& rowkey);
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
   static int estimate_row_count(const common::ObQueryFlag query_flag, const uint64_t table_id,
       const common::ObExtStoreRowkey& rowkey, const common::ObIArray<ObITable*>& stores, ObPartitionEst& part_estimate);
@@ -33,7 +33,7 @@ protected:
   virtual int calc_scan_range() override;
   virtual int construct_iters() override;
   virtual int is_range_valid() const override;
-  virtual int inner_get_next_row(ObStoreRow& row);
+  virtual int inner_get_next_row(ObStoreRow& row) override;
   virtual void collect_merge_stat(ObTableStoreStat& stat) const override;
 
 private:
diff --git a/src/storage/ob_sstable_multi_version_row_iterator.h b/src/storage/ob_sstable_multi_version_row_iterator.h
index 7ee123b21eb88e239e1b56e10c6349f7ded5cfe7..aa9f70d2303c34204bcf6c5a80ac56b84efef9f2 100644
--- a/src/storage/ob_sstable_multi_version_row_iterator.h
+++ b/src/storage/ob_sstable_multi_version_row_iterator.h
@@ -25,7 +25,7 @@ class ObSSTableMultiVersionRowIterator : public ObISSTableRowIterator {
 public:
   ObSSTableMultiVersionRowIterator();
   virtual ~ObSSTableMultiVersionRowIterator();
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
 
 protected:
diff --git a/src/storage/ob_sstable_row_getter.h b/src/storage/ob_sstable_row_getter.h
index dc201c19b0364ca64fbf634fa6e2afa41c7b0e5c..0be0113bb3c35d684bbbafdc716926d8be2e596f 100644
--- a/src/storage/ob_sstable_row_getter.h
+++ b/src/storage/ob_sstable_row_getter.h
@@ -22,14 +22,14 @@ class ObSSTableRowGetter : public ObSSTableRowIterator {
 public:
   ObSSTableRowGetter();
   virtual ~ObSSTableRowGetter();
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
 
 protected:
-  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt);
-  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle);
-  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row);
-  virtual int get_range_count(const void* query_range, int64_t& range_count) const;
+  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt) override;
+  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle) override;
+  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row) override;
+  virtual int get_range_count(const void* query_range, int64_t& range_count) const override;
 
 protected:
   bool has_prefetched_;
diff --git a/src/storage/ob_sstable_row_iterator.h b/src/storage/ob_sstable_row_iterator.h
index 362fdadb685d861f98fb2c35a84d5bab6c52a323..dadb33b82a4346c578ddaee16b4e68e6f3101f59 100644
--- a/src/storage/ob_sstable_row_iterator.h
+++ b/src/storage/ob_sstable_row_iterator.h
@@ -319,7 +319,7 @@ class ObSSTableRowIterator : public ObISSTableRowIterator {
 public:
   ObSSTableRowIterator();
   virtual ~ObSSTableRowIterator();
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
   virtual int get_skip_range_ctx(
       ObSSTableReadHandle& read_handle, const int64_t cur_micro_idx, ObSSTableSkipRangeCtx*& skip_ctx);
@@ -337,9 +337,9 @@ public:
   }
 
 protected:
-  virtual int inner_open(
-      const ObTableIterParam& access_param, ObTableAccessContext& access_ctx, ObITable* table, const void* query_range);
-  virtual int inner_get_next_row(const ObStoreRow*& store_row);
+  virtual int inner_open(const ObTableIterParam& access_param, ObTableAccessContext& access_ctx, ObITable* table,
+      const void* query_range) override;
+  virtual int inner_get_next_row(const ObStoreRow*& store_row) override;
   virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt) = 0;
   virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle) = 0;
   virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row) = 0;
diff --git a/src/storage/ob_sstable_row_lock_checker.h b/src/storage/ob_sstable_row_lock_checker.h
index ad816dfaaac0d95fc673935a33624c6926a996de..483f4bf59d44d02d69991b797634624c1998a2c5 100644
--- a/src/storage/ob_sstable_row_lock_checker.h
+++ b/src/storage/ob_sstable_row_lock_checker.h
@@ -38,7 +38,7 @@ public:
   }
 
 protected:
-  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row);
+  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row) override;
   virtual void set_row_snapshot(ObStoreRow& row) override;
 
 private:
diff --git a/src/storage/ob_sstable_row_multi_getter.h b/src/storage/ob_sstable_row_multi_getter.h
index e2cc2a34ec5125d9e55299cf6a68e1ed579e402b..f24ca347900ada72b210001c73d4f43297cc0fd8 100644
--- a/src/storage/ob_sstable_row_multi_getter.h
+++ b/src/storage/ob_sstable_row_multi_getter.h
@@ -22,14 +22,14 @@ class ObSSTableRowMultiGetter : public ObSSTableRowGetter {
 public:
   ObSSTableRowMultiGetter();
   virtual ~ObSSTableRowMultiGetter();
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
   virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key) override;
 
 protected:
-  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt);
-  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle);
-  virtual int get_range_count(const void* query_range, int64_t& range_count) const;
+  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt) override;
+  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle) override;
+  virtual int get_range_count(const void* query_range, int64_t& range_count) const override;
   virtual int get_skip_range_ctx(
       ObSSTableReadHandle& read_handle, const int64_t cur_micro_idx, ObSSTableSkipRangeCtx*& ctx) override;
 
diff --git a/src/storage/ob_sstable_row_multi_scanner.h b/src/storage/ob_sstable_row_multi_scanner.h
index d0a90827bf15ad0c9390d6d39cdcf0b2a1a33ff6..b101ec5a4f71f9ebb6031badcb75532c9151ca9c 100644
--- a/src/storage/ob_sstable_row_multi_scanner.h
+++ b/src/storage/ob_sstable_row_multi_scanner.h
@@ -22,15 +22,15 @@ class ObSSTableRowMultiScanner : public ObSSTableRowScanner {
 public:
   ObSSTableRowMultiScanner();
   virtual ~ObSSTableRowMultiScanner();
-  virtual void reset();
-  virtual void reuse();
+  virtual void reset() override;
+  virtual void reuse() override;
   virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key) override;
 
 protected:
-  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt);
-  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle);
-  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row);
-  virtual int get_range_count(const void* query_range, int64_t& range_count) const;
+  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt) override;
+  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle) override;
+  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row) override;
+  virtual int get_range_count(const void* query_range, int64_t& range_count) const override;
 
 private:
   static const int64_t MULTISCAN_READ_HANDLE_CNT = 32;
diff --git a/src/storage/ob_sstable_row_scanner.h b/src/storage/ob_sstable_row_scanner.h
index 0eabeace184bbada5d7362a27b4341c5edbfb470..e10395ad26cb755fceeefce8a15809721b62ea57 100644
--- a/src/storage/ob_sstable_row_scanner.h
+++ b/src/storage/ob_sstable_row_scanner.h
@@ -22,7 +22,7 @@ class ObSSTableRowScanner : public ObSSTableRowIterator {
 public:
   ObSSTableRowScanner();
   virtual ~ObSSTableRowScanner();
-  virtual void reset();
+  virtual void reset() override;
   virtual void reuse() override;
   virtual int skip_range(int64_t range_idx, const common::ObStoreRowkey* gap_key, const bool include_gap_key) override;
   int skip_range_impl(const int64_t range_idx, const ObExtStoreRange& org_range, const ObExtStoreRange& new_range);
@@ -35,15 +35,15 @@ public:
   int get_row_iter_flag_impl(uint8_t& flag);
 
 protected:
-  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt);
-  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle);
-  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row);
+  virtual int get_handle_cnt(const void* query_range, int64_t& read_handle_cnt, int64_t& micro_handle_cnt) override;
+  virtual int prefetch_read_handle(ObSSTableReadHandle& read_handle) override;
+  virtual int fetch_row(ObSSTableReadHandle& read_handle, const ObStoreRow*& store_row) override;
   int prefetch_range(
       const int64_t range_idx, const common::ObExtStoreRange& ext_range, ObSSTableReadHandle& read_handle);
   int check_can_skip_range(const int64_t range_idx, const common::ObStoreRowkey& gap_key, bool& can_skip);
   int prefetch_block_index(const uint64_t table_id, const blocksstable::ObMacroBlockCtx& block_ctx,
       ObMicroBlockIndexHandle& block_index_handle);
-  virtual int get_range_count(const void* query_range, int64_t& range_count) const;
+  virtual int get_range_count(const void* query_range, int64_t& range_count) const override;
 
 private:
   int skip_batch_rows(
diff --git a/src/storage/ob_store_row_filter.h b/src/storage/ob_store_row_filter.h
index 4925c198aa06e0ed5ff6cf069997680b3552fb6e..693a890d1d9e5a6a6b5fcefb37c41df426784823 100644
--- a/src/storage/ob_store_row_filter.h
+++ b/src/storage/ob_store_row_filter.h
@@ -43,7 +43,7 @@ public:
   virtual ~ObStoreRowFilter()
   {}
   int init(const sql::ObTableLocation* part_filter, sql::ObExecContext* exec_ctx, common::ObPartMgr* part_mgr,
-      const common::ObPartitionKey& pkey);
+      const common::ObPartitionKey& pkey) override;
   int check(const ObStoreRow& store_row, bool& is_filtered) const override;
   TO_STRING_KV(KP_(part_filter), KP_(exec_ctx), KP_(part_mgr), K_(pkey));
 
diff --git a/src/storage/ob_table_scan_iterator.h b/src/storage/ob_table_scan_iterator.h
index aa39e977f5bd0b4fccc9169814b2bc4c08735962..d8d69bd2f6b5dd6ba4346c75784317df70201ca0 100644
--- a/src/storage/ob_table_scan_iterator.h
+++ b/src/storage/ob_table_scan_iterator.h
@@ -98,9 +98,9 @@ public:
     common::ObNewRow* r = NULL;
     return get_next_row(r);
   }
-  virtual void reset();
+  virtual void reset() override;
   int set_range_array_idx(const int64_t range_array_idx);
-  virtual int release_table_ref();
+  virtual int release_table_ref() override;
 private:
   bool is_inited_;
   ObTableScanStoreRowIterator* row_iter_;
@@ -152,7 +152,7 @@ public:
       ObPartitionStore& partition_store);
   int rescan(ObTableScanParam& scan_param);
   virtual void reset() override;
-  virtual int release_table_ref();
+  virtual int release_table_ref() override;
 private:
   ObTableScanIterIterator iter_;
   ObNewRowIterator* row_iter_;
diff --git a/src/storage/transaction/ob_trans_part_ctx.h b/src/storage/transaction/ob_trans_part_ctx.h
index e6e8695f0ccd9058c5e62ec25ea12c9d42df1dd0..a27861e76868719bb23cf2923827d2ecf2e546b6 100644
--- a/src/storage/transaction/ob_trans_part_ctx.h
+++ b/src/storage/transaction/ob_trans_part_ctx.h
@@ -112,7 +112,7 @@ public:
       const common::ObPartitionKey& self, ObITransCtxMgr* ctx_mgr, const ObStartTransParam& trans_param,
       const uint64_t cluster_version, ObTransService* trans_service, const uint64_t cluster_id,
       const int64_t leader_epoch, const bool can_elr);
-  virtual void destroy();
+  virtual void destroy() override;
   void reset();
   int construct_context(const ObTransMsg& msg);
 
@@ -125,13 +125,13 @@ public:
   int end_task_(
       const bool is_rollback, const ObTransDesc& trans_desc, const int64_t sql_no, const int64_t stmt_min_sql_no);
   int handle_message(const ObTransMsg& msg);
-  bool is_inited() const;
-  int handle_timeout(const int64_t delay);
+  bool is_inited() const override;
+  int handle_timeout(const int64_t delay) override;
   int get_end_trans_callback_item(ObEndTransCallbackArray& cb_array);
   /*
    * graceful kill: wait trx finish logging
    */
-  int kill(const KillTransArg& arg, ObEndTransCallbackArray& cb_array);
+  int kill(const KillTransArg& arg, ObEndTransCallbackArray& cb_array) override;
   int wait_1pc_trx_end_in_spliting(bool& trx_end);
   int check_cur_partition_split_(bool& is_split_partition);
   memtable::ObMemtableCtx* get_memtable_ctx()
@@ -139,14 +139,14 @@ public:
     return &mt_ctx_;
   }
   int set_memtable_ctx(memtable::ObIMemtableCtx* mt_ctx);
-  int leader_revoke(const bool first_check, bool& need_release, ObEndTransCallbackArray& cb_array);
-  int leader_takeover(const int64_t checkpoint);
-  int leader_active(const storage::LeaderActiveArg& arg);
-  bool can_be_freezed() const;
+  int leader_revoke(const bool first_check, bool& need_release, ObEndTransCallbackArray& cb_array) override;
+  int leader_takeover(const int64_t checkpoint) override;
+  int leader_active(const storage::LeaderActiveArg& arg) override;
+  bool can_be_freezed() const override;
   int kill_trans(bool& need_convert_to_dist_trans);
   int commit(const bool is_rollback, sql::ObIEndTransCallback* cb, bool is_readonly, const MonotonicTs commit_time,
       const int64_t stmt_expired_time, const ObStmtRollbackInfo& stmt_rollback_info,
-      const common::ObString& app_trace_info, bool& need_convert_to_dist_trans);
+      const common::ObString& app_trace_info, bool& need_convert_to_dist_trans) override;
   int set_stmt_info(const ObTransStmtInfo& stmt_info);
   const ObTransStmtInfo& get_stmt_info() const
   {
@@ -171,21 +171,21 @@ public:
   {
     return get_global_trans_version_();
   }
-  uint64_t hash() const
+  uint64_t hash() const override
   {
     return trans_id_.hash();
   }
-  int get_gts_callback(const MonotonicTs srr, const int64_t gts, const MonotonicTs receive_gts_ts);
-  int gts_elapse_callback(const MonotonicTs srr, const int64_t gts);
-  MonotonicTs get_stc() const
+  int get_gts_callback(const MonotonicTs srr, const int64_t gts, const MonotonicTs receive_gts_ts) override;
+  int gts_elapse_callback(const MonotonicTs srr, const int64_t gts) override;
+  MonotonicTs get_stc() const override
   {
     return stc_;
   }
-  int64_t get_request_ts() const
+  int64_t get_request_ts() const override
   {
     return gts_request_ts_;
   }
-  uint64_t get_tenant_id() const
+  uint64_t get_tenant_id() const override
   {
     return tenant_id_;
   }