fix typo (oceanbase#54)

Author: raywill

deps/oblib/src/lib/ob_define.h

@@ -288,7 +288,7 @@ const int64_t OB_MAX_TRANS_ID_BUFFER_SIZE = 512;
 const int32_t OB_MIN_SAFE_COPY_COUNT = 3;
 const int32_t OB_SAFE_COPY_COUNT = 3;
 const int32_t OB_DEFAULT_REPLICA_NUM = 3;
-const int32_t OB_DEC_AND_LOCK = 2626;                                /* used by remoe_plan in ObPsStore */
+const int32_t OB_DEC_AND_LOCK = 2626;                                /* used by remote_plan in ObPsStore */
 const int32_t OB_MAX_SCHEMA_VERSION_INTERVAL = 40 * 1000 * 1000;     // 40s
 const int64_t UPDATE_SCHEMA_ADDITIONAL_INTERVAL = 5 * 1000 * 1000L;  // 5s
 
@@ -834,7 +834,7 @@ const uint64_t OB_GTS_UNIT_ID = 100;
 const int64_t OB_GTS_QUORUM = 3;
 const char* const OB_ORIGINAL_GTS_NAME = "primary_gts_instance";
 const uint64_t OB_ORIGINAL_GTS_ID = 100;
-// standby unit config tmplate
+// standby unit config template
 const char* const OB_STANDBY_UNIT_CONFIG_TEMPLATE_NAME = "standby_unit_config_template";
 
 const uint64_t OB_SCHEMATA_TID = 2001;
@@ -1494,7 +1494,7 @@ const int64_t OB_MAX_CPU_NUM = 128;
 const int64_t OB_MAX_STATICS_PER_TABLE = 128;
 
 const uint64_t OB_DEFAULT_INDEX_ATTRIBUTES_SET = 0;
-const uint64_t OB_DEFAULT_INDEX_VISIBILITY = 0;  // 0 menas visible;1 means invisible
+const uint64_t OB_DEFAULT_INDEX_VISIBILITY = 0;  // 0 means visible;1 means invisible
 
 const int64_t OB_INDEX_WRITE_START_DELAY = 20 * 1000 * 1000;  // 20s
 

deps/oblib/src/lib/ob_name_def.h

@@ -228,7 +228,7 @@
 #define N_ROWKEY_LIST "rowkey_list"
 #define N_READ_MASTER "read_master"
 #define N_RESULT_CACHED "result_cached"
-#define N_NOT_EXIST_COL_RET_NOP "not_exsit_col_ret_as_nop"
+#define N_NOT_EXIST_COL_RET_NOP "not_exist_col_ret_as_nop"
 #define N_RAW_EXPR "raw_expr"
 #define N_ROWKEY_CELL_NUM "rowkey_cell_num"
 #define N_CELL "cell"

deps/oblib/src/lib/ob_name_id_def.h

@@ -149,7 +149,7 @@ DEF_NAME(revert_scan_iter, "revert scan iterator")
 DEF_NAME(get_row, "get row")
 DEF_NAME(plc_sys_cache_get, "plc sys cache get end")
 DEF_NAME(plc_user_cache_get_end, "plc user cache get end")
-DEF_NAME(tl_calc_parid_end, "tl calc part id end")
+DEF_NAME(tl_calc_partid_end, "tl calc part id end")
 DEF_NAME(tl_calc_by_range_end, "tl calc by range end")
 DEF_NAME(pc_fast_parse_start, "pc fast parse start")
 DEF_NAME(pc_fast_parse_end, "pc fast parse end")
@@ -326,9 +326,9 @@ DEF_NAME(send_devote_vote, "send devote vote")
 DEF_NAME(send_vote_vote, "send vote vote")
 DEF_NAME(send_devote_success, "send devote success")
 DEF_NAME(send_vote_success, "send vote success")
-DEF_NAME(try_centrialized_voting, "try centrialized voting")
-DEF_NAME(check_decentrialized_majority, "check decentrialized majority")
-DEF_NAME(check_centrialized_majority, "check centrialized majority")
+DEF_NAME(try_centralized_voting, "try centralized voting")
+DEF_NAME(check_decentralized_majority, "check decentralized majority")
+DEF_NAME(check_centralized_majority, "check centralized majority")
 DEF_NAME(upgrade_mode, "upgrade mode")
 DEF_NAME(run_gt1_task, "run gt1 task")
 DEF_NAME(response_scheduler, "response scheduler")
@@ -411,7 +411,7 @@ DEF_NAME(max_log_ack_list, "max log ack list")
 DEF_NAME(replay_start_working_log, "replay start working log")
 // perf event
 DEF_NAME(S_scan_iter, "storage: scan iterator")
-DEF_NAME(pc_fast_gen_stmt_key_end, "plan cache: fast genarate stmt_key")
+DEF_NAME(pc_fast_gen_stmt_key_end, "plan cache: fast generate stmt_key")
 DEF_NAME(pc_plan_cache_hit, "plan cache: init")
 DEF_NAME(FROM_resolved, "resolver: from clause")
 DEF_NAME(SELECT_resolved, "resolver: select clause")
@@ -478,11 +478,10 @@ DEF_NAME(revert_insert_iter, "revert_insert_iter")
 DEF_NAME(revert_insert_iter_end, "revert_insert_iter_end")
 DEF_NAME(revert_scan_iter_end, "revert_scan_iter_end")
 DEF_NAME(replace_end, "replace_end")
-DEF_NAME(repalce_start_insert, "repalce_start_insert")
+DEF_NAME(replace_start_insert, "replace_start_insert")
 DEF_NAME(replace_end_insert, "replace_end_insert")
 DEF_NAME(replace_start_delete, "replace_start_delete")
 DEF_NAME(replace_end_delete, "replace_end_delete")
-DEF_NAME(replace_start_insert, "replace_start_insert")
 DEF_NAME(replace_start_scan_row, "replace_start_scan_row")
 DEF_NAME(replace_start_table_scan, "replace_start_table_scan")
 DEF_NAME(replace_end_table_scan, "replace_end_table_scan")

deps/oblib/src/lib/oblog/ob_log.cpp

@@ -2059,7 +2059,7 @@ int64_t ObLogger::get_wait_us(const int32_t level)
       default: {
         ret_timeout_us = 0;  // 0us
         break;
-        // do nothiong
+        // do nothing
       }
     }
   }

deps/oblib/src/lib/oblog/ob_log.h

@@ -214,7 +214,7 @@ class ObPLogItem;
   }
 
 //@class ObLogIdLevelMap
-//@brief stroe the level of each par-module and sub-module. The key is module ID.
+//@brief store the level of each par-module and sub-module. The key is module ID.
 //       To be used for SQL hint, this class should be POD-type.
 struct ObLogIdLevelMap {
   static const uint64_t MAX_PAR_MOD_SIZE = OB_LOG_MAX_PAR_MOD_SIZE;
@@ -759,8 +759,8 @@ class ObLogger : public ObBaseLogWriter {
   //@param[in] flag Whether redirect the stdout and stderr to the descriptor of the log-file.
   // FALSE:redirect TRUE:no redirect.
   //@param[in] open_wf whether create warning log-file to store warning buffer.
-  //@param[in] finename of rootservice log-file's name.
-  //@param[in] finename of election log-file's name.
+  //@param[in] filename of rootservice log-file's name.
+  //@param[in] filename of election log-file's name.
   void set_file_name(const char* filename, const bool no_redirect_flag = false, const bool open_wf = false,
       const char* rs_filename = NULL, const char* elec_filename = NULL);
 
@@ -937,10 +937,10 @@ class ObLogger : public ObBaseLogWriter {
   //@brief Rename the log to a filename with fmt. And open a new file with the old, then add old file to file_list.
   //@param[in] filename the old filename to rotate.
   //@param[in] whether redirect, FALSE:redirect TRUE:no redirect
-  //@param[out] after retated log, open new file_fd
-  //@param[out] after retated wf log, open new wf_file_fd
-  //@param[out] add retated log file name to file list
-  //@param[out] add retated wf log file name to file list
+  //@param[out] after rotated log, open new file_fd
+  //@param[out] after rotated wf log, open new wf_file_fd
+  //@param[out] add rotated log file name to file list
+  //@param[out] add rotated wf log file name to file list
   void rotate_log(const char* filename, const ObPLogFDType fd_type, const bool redirect_flag, int32_t& fd,
       int32_t& wf_fd, std::deque<std::string>& file_list, std::deque<std::string>& wf_file_list);
 
@@ -966,7 +966,7 @@ class ObLogger : public ObBaseLogWriter {
 
   private:
   static const char* const errstr_[];
-  // default log rate limiter if there's no tl_log_limiger
+  // default log rate limiter if there's no tl_log_limiter
   static ::oceanbase::lib::ObRateLimiter* default_log_limiter_;
   static RLOCAL(lib::ObRateLimiter*, tl_log_limiter_);
   static constexpr int N_LIMITER = 4096;
@@ -1004,8 +1004,8 @@ class ObLogger : public ObBaseLogWriter {
   bool force_check_;         // whether check log-file at each message logging.
   bool redirect_flag_;       // whether redirect, TRUE: redirect FALSE: no redirect.
   bool open_wf_flag_;        // whether open warning log-file.
-  bool enable_wf_flag_;      // whether write waring log to wf log-file.
-  bool rec_old_file_flag_;   // whether recorde old file.
+  bool enable_wf_flag_;      // whether write warning log to wf log-file.
+  bool rec_old_file_flag_;   // whether record old file.
   volatile bool can_print_;  // when disk has no space, logger control
 
   bool enable_async_log_;  // if false, use sync way logging

src/election/ob_election.cpp

@@ -758,8 +758,8 @@ int ObElection::process_vote_prepare_(const ObElectionMsgPrepare& msg)
         ELECT_ASYNC_LOG_(WARN, "store prepare message error", K(ret), K(*this), K(msg));
       } else {
         // T1_timestamp_ = msg.get_T1_timestamp();
-        if (OB_FAIL(try_centrialized_voting_(now_lease_time, msg.get_T1_timestamp()))) {
-          ELECT_ASYNC_LOG_(WARN, "try centrialized voting error", K(ret), K(*this), K(msg), K(now_lease_time));
+        if (OB_FAIL(try_centralized_voting_(now_lease_time, msg.get_T1_timestamp()))) {
+          ELECT_ASYNC_LOG_(WARN, "try centralized voting error", K(ret), K(*this), K(msg), K(now_lease_time));
         }
       }
     }
@@ -895,8 +895,8 @@ int ObElection::process_vote_vote_(const ObElectionMsgVote& msg)
         ELECT_ASYNC_LOG_(WARN, "collect_valid_candidates error", K(ret), K_(partition), K(msg));
       } else if (OB_FAIL(msg_pool_.store(msg))) {
         ELECT_ASYNC_LOG_(WARN, "store vote message error", K(ret), K(*this), K(msg));
-      } else if (OB_FAIL(check_centrialized_majority_())) {
-        ELECT_ASYNC_LOG_(WARN, "check_centrialized_majority error", K(ret), K(*this), K(msg));
+      } else if (OB_FAIL(check_centralized_majority_())) {
+        ELECT_ASYNC_LOG_(WARN, "check_centralized_majority error", K(ret), K(*this), K(msg));
       } else {
         // do nothing
       }
@@ -3186,7 +3186,7 @@ int ObElection::send_devote_vote_(const ObAddr& server, const ObElectionMsgDEVot
   return ret;
 }
 
-int ObElection::try_centrialized_voting_(const int64_t lease_time, int64_t msg_t1)
+int ObElection::try_centralized_voting_(const int64_t lease_time, int64_t msg_t1)
 {
   int ret = OB_SUCCESS;
   ObAddr msg_cur_leader;
@@ -3255,7 +3255,7 @@ int ObElection::try_centrialized_voting_(const int64_t lease_time, int64_t msg_t
 //   if self is in reappointing, need majority's message
 //   if self is in changing leader, need majority's message and new leader's message
 // 2.if there are enough messages, send vote success message
-int ObElection::check_centrialized_majority_()
+int ObElection::check_centralized_majority_()
 {
   int ret = OB_SUCCESS;
   ObAddr cur_leader;

src/election/ob_election.h

@@ -286,8 +286,8 @@ class ObElection : public ObIElection, public ObIElectionTimerP, public ObElecti
   bool change_leader_time_out_of_range_(const int64_t cur_ts, const int64_t expect_ts) const;
   int get_decentralized_candidate_(common::ObAddr& server, ObElectionPriority& priority, int64_t& lease_time);
   int get_centralized_candidate_(common::ObAddr& cur_leader, common::ObAddr& new_leader, int64_t msg_t1);
-  int try_centrialized_voting_(const int64_t lease_time, int64_t msg_t1);
-  int check_centrialized_majority_();
+  int try_centralized_voting_(const int64_t lease_time, int64_t msg_t1);
+  int check_centralized_majority_();
   int check_decentralized_majority_(common::ObAddr& new_leader, int64_t& ticket);
   int collect_valid_candidates_(const ObElectionMsgVote& msg);
   int send_devote_prepare_(const ObElectionMsgDEPrepare& msg);

src/election/ob_election_group.cpp

@@ -807,15 +807,15 @@ int ObElectionGroup::process_vote_prepare_(const ObElectionMsgEGPrepare& msg, co
         ELECT_ASYNC_LOG_(WARN, "store prepare message error", K(ret), "election_group", *this, K(msg));
       } else {
         T1_timestamp_ = msg_t1;
-        if (OB_FAIL(try_centrialized_voting_(now_lease_time))) {
-          ELECT_ASYNC_LOG_(WARN, "try centrialized voting error", K(ret), "self", *this, K(msg), K(now_lease_time));
+        if (OB_FAIL(try_centralized_voting_(now_lease_time))) {
+          ELECT_ASYNC_LOG_(WARN, "try centralized voting error", K(ret), "self", *this, K(msg), K(now_lease_time));
         } else {
           if (msg_eg_version != eg_version_ && ROLE_SLAVE == role_) {
             ELECT_ASYNC_LOG_(
                 INFO, "eg_version not equal with leader when send_vote_vote", K(msg), K(msg_eg_version), "self", *this);
           }
         }
-        REC_TRACE_EXT(tlog_, try_centrialized_voting, Y(ret), Y_(vote_period), Y(lease_time));
+        REC_TRACE_EXT(tlog_, try_centralized_voting, Y(ret), Y_(vote_period), Y(lease_time));
       }
     }
   }
@@ -896,7 +896,7 @@ int ObElectionGroup::handle_vote_prepare(
   return ret;
 }
 
-int ObElectionGroup::try_centrialized_voting_(const int64_t lease_time)
+int ObElectionGroup::try_centralized_voting_(const int64_t lease_time)
 {
   int ret = OB_SUCCESS;
   ObAddr msg_cur_leader;
@@ -1162,7 +1162,7 @@ void ObElectionGroup::clear_part_stat_vote_cnt_()
 // receive new message
 // 1. check if received enough messages
 // 2. if so, send vote success message
-int ObElectionGroup::check_centrialized_majority_()
+int ObElectionGroup::check_centralized_majority_()
 {
   int ret = OB_SUCCESS;
   ObAddr cur_leader;
@@ -1184,7 +1184,7 @@ int ObElectionGroup::check_centrialized_majority_()
     if (OB_ELECTION_WARN_NOT_REACH_MAJORITY == ret || OB_ELECTION_WAIT_LEADER_MESSAGE == ret) {
       // no enough message or waiting for leader's message
     } else {
-      ELECT_ASYNC_LOG_(WARN, "check_centrialized_majority_ error", K(ret), K_(eg_id));
+      ELECT_ASYNC_LOG_(WARN, "check_centralized_majority_ error", K(ret), K_(eg_id));
     }
   } else {
     bool arg_all_part_merged_in = is_all_part_merged_in_;
@@ -1229,7 +1229,7 @@ int ObElectionGroup::check_centrialized_majority_()
       }
     } else {
       ret = OB_STATE_NOT_MATCH;
-      FORCE_ELECT_LOG(WARN, "check_centrialized_majority_ error", K(ret), K(*this), K(cur_leader));
+      FORCE_ELECT_LOG(WARN, "check_centralized_majority_ error", K(ret), K(*this), K(cur_leader));
     }
   }
   clear_part_stat_vote_cnt_();
@@ -1957,10 +1957,10 @@ void ObElectionGroup::run_gt3_task(const int64_t expect_ts)
     ELECT_ASYNC_LIMIT_LOG(
         WARN, "run time out of range", K(ret), "self", *this, K(cur_ts), K(expect_ts), "delta", cur_ts - expect_ts);
   } else {
-    if (OB_FAIL(check_centrialized_majority_())) {
-      ELECT_ASYNC_LOG_(WARN, "check_centrialized_majority_ error", K(ret), "self", *this);
+    if (OB_FAIL(check_centralized_majority_())) {
+      ELECT_ASYNC_LOG_(WARN, "check_centralized_majority_ error", K(ret), "self", *this);
     }
-    REC_TRACE_EXT(tlog_, check_centrialized_majority, Y(ret));
+    REC_TRACE_EXT(tlog_, check_centralized_majority, Y(ret));
   }
   ELECT_ASYNC_LOG(DEBUG, "GT3Task", K(ret), "self", *this, K(expect_ts), K(cur_ts));
 }

src/election/ob_election_group.h

@@ -264,8 +264,8 @@ class ObElectionGroup : public ObIElectionGroup, public ObIElectionTimerP {
   bool run_time_out_of_range_(const int64_t cur_ts, const int64_t expect_ts) const;
   bool vote_run_time_out_of_range_(const int64_t cur_ts, const int64_t expect_ts) const;
   int get_eg_centralized_candidate_(common::ObAddr& cur_leader, common::ObAddr& new_leader);
-  int try_centrialized_voting_(const int64_t lease_time);
-  int check_centrialized_majority_();
+  int try_centralized_voting_(const int64_t lease_time);
+  int check_centralized_majority_();
   void set_unconfirmed_leader_(const common::ObAddr& unconfirmed_leader);
   int set_unconfirmed_leader_lease_(const int64_t start, const int64_t end);
   bool unconfirmed_leader_lease_is_expired_(const int64_t cur_ts) const;

src/sql/engine/dml/ob_table_replace.cpp

@@ -413,7 +413,7 @@ int ObTableReplace::try_insert(ObExecContext& ctx, ObExprCtx& expr_ctx, const Ob
     }
     SQL_ENG_LOG(DEBUG, "calc row for insert:", K(ret), K(replace_ctx->insert_row_));
     replace_ctx->record_++;
-    NG_TRACE_TIMES(2, repalce_start_insert);
+    NG_TRACE_TIMES(2, replace_start_insert);
     if (OB_SUCC(partition_service->insert_row(my_session->get_trans_desc(),
             dml_param,
             part_key,