init push

src/sql/resolver/cmd/ob_alter_system_resolver.h

@@ -0,0 +1,193 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_RESOLVER_CMD_OB_ALTER_SYSTEM_RESOLVER_
+#define OCEANBASE_RESOLVER_CMD_OB_ALTER_SYSTEM_RESOLVER_
+
+#include "sql/resolver/cmd/ob_system_cmd_resolver.h"
+
+namespace oceanbase {
+namespace common {
+class ObAddr;
+class ObPartitionKey;
+}  // namespace common
+namespace sql {
+class ObSystemCmdStmt;
+class ObAlterSystemResolverUtil {
+  public:
+  static int sanity_check(const ParseNode* parse_tree, ObItemType item_type);
+
+  // resolve opt_ip_port
+  static int resolve_server(const ParseNode* parse_tree, common::ObAddr& server);
+  // resolve server string (value part of opt_ip_port)
+  static int resolve_server_value(const ParseNode* parse_tree, common::ObAddr& server);
+  // resolve opt_zone_desc
+  static int resolve_zone(const ParseNode* parse_tree, common::ObZone& zone);
+  // resolve opt_tenant_name
+  static int resolve_tenant(
+      const ParseNode* parse_tree, common::ObFixedLengthString<common::OB_MAX_TENANT_NAME_LENGTH + 1>& tenant_name);
+  // resolve partition_id_desc
+  static int resolve_partition_id(
+      const uint64_t tenant_id, const ParseNode* parse_tree, common::ObPartitionKey& partition_key);
+  // parse "partition_idx%partition_num@table_id" to partition key
+  static int parse_partition_id_desc(
+      const uint64_t tenant_id, const char* partition_id, common::ObPartitionKey& partition_key);
+
+  static int resolve_replica_type(const ParseNode* parse_tree, common::ObReplicaType& replica_type);
+  static int resolve_memstore_percent(const ParseNode* parse_tree, ObReplicaProperty& replica_property);
+  static int resolve_string(const ParseNode* parse_tree, common::ObString& string);
+  static int resolve_relation_name(const ParseNode* parse_tree, common::ObString& string);
+  static int resolve_force_opt(const ParseNode* parse_tree, bool& force_cmd);
+  // resolve opt_server_or_zone
+  template <typename RPC_ARG>
+  static int resolve_server_or_zone(const ParseNode* parse_tree, RPC_ARG& arg);
+};
+
+#define DEF_SIMPLE_CMD_RESOLVER(name)                            \
+  class name : public ObSystemCmdResolver {                      \
+    public:                                                      \
+    name(ObResolverParams& params) : ObSystemCmdResolver(params) \
+    {}                                                           \
+    virtual ~name()                                              \
+    {}                                                           \
+    virtual int resolve(const ParseNode& parse_tree);            \
+  };
+
+DEF_SIMPLE_CMD_RESOLVER(ObFreezeResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObFlushCacheResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObFlushKVCacheResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObFlushIlogCacheResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObFlushDagWarningsResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObLoadBaselineResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObAdminServerResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObAdminZoneResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObSwitchReplicaRoleResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObDropReplicaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObChangeReplicaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObMigrateReplicaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObReportReplicaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObRecycleReplicaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObAdminMergeResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObClearRootTableResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObRefreshSchemaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObRefreshMemStatResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObSetTPResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObClearLocationCacheResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObReloadGtsResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObReloadUnitResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObReloadServerResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObReloadZoneResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObClearMergeErrorResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObMigrateUnitResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObUpgradeVirtualSchemaResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObRunJobResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObRunUpgradeJobResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObStopUpgradeJobResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObSwitchRSRoleResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObAdminUpgradeCmdResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObAdminRollingUpgradeCmdResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObRefreshTimeZoneInfoResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObCancelTaskResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObRestoreTenantResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObSetDiskValidResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObClearBalanceTaskResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObChangeTenantResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObDropTempTableResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObRefreshTempTableResolver);
+
+DEF_SIMPLE_CMD_RESOLVER(ObAlterDiskgroupAddDiskResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObAlterDiskgroupDropDiskResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObArchiveLogResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObBackupDatabaseResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObBackupManageResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObBackupSetEncryptionResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObBackupSetDecryptionResolver);
+
+class ObPhysicalRestoreTenantResolver : public ObSystemCmdResolver {
+  public:
+  ObPhysicalRestoreTenantResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
+  {}
+  virtual ~ObPhysicalRestoreTenantResolver()
+  {}
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  int resolve_decryption_passwd(obrpc::ObPhysicalRestoreTenantArg& arg);
+};
+
+class ObAlterSystemSetResolver : public ObSystemCmdResolver {
+  public:
+  ObAlterSystemSetResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
+  {}
+  virtual ~ObAlterSystemSetResolver()
+  {}
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  int check_param_valid(int64_t tenant_id, const common::ObString& name_node, const common::ObString& value_node);
+};
+
+class ObSetConfigResolver : public ObSystemCmdResolver {
+  public:
+  ObSetConfigResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
+  {}
+  virtual ~ObSetConfigResolver()
+  {}
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  int check_param_valid(int64_t tenant_id, const common::ObString& name_node, const common::ObString& value_node);
+};
+
+DEF_SIMPLE_CMD_RESOLVER(ObEnableSqlThrottleResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObDisableSqlThrottleResolver);
+
+#undef DEF_SIMPLE_CMD_RESOLVER
+
+}  // end namespace sql
+}  // end namespace oceanbase
+#endif  // OCEANBASE_RESOLVER_CMD_OB_ALTER_SYSTEM_RESOLVER_

src/sql/resolver/cmd/ob_alter_system_stmt.cpp

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SHARE
+#include "ob_alter_system_stmt.h"
+#include "lib/encrypt/ob_encrypted_helper.h"
+
+using namespace oceanbase;
+using namespace lib;
+using namespace common;
+using namespace share;
+using namespace sql;
+
+ObBackupSetEncryptionStmt::ObBackupSetEncryptionStmt()
+    : ObSystemCmdStmt(stmt::T_BACKUP_SET_ENCRYPTION),
+      mode_(share::ObBackupEncryptionMode::MAX_MODE),
+      encrypted_passwd_()
+{
+  passwd_buf_[0] = '\0';
+}
+
+int ObBackupSetEncryptionStmt::set_param(const int64_t mode, const common::ObString& passwd)
+{
+  int ret = common::OB_SUCCESS;
+  mode_ = static_cast<const share::ObBackupEncryptionMode::EncryptionMode>(mode);
+  encrypted_passwd_.assign_ptr(passwd_buf_, sizeof(passwd_buf_));
+
+  if (!share::ObBackupEncryptionMode::is_valid(mode_)) {
+    ret = OB_INVALID_ARGUMENT;
+    COMMON_LOG(WARN, "invalid args", K(ret), K(mode), K(mode_));
+  } else if (OB_FAIL(ObEncryptedHelper::encrypt_passwd_to_stage2(passwd, encrypted_passwd_))) {
+    COMMON_LOG(WARN, "failed to encrypted passwd", K(ret), K(passwd));
+  }
+
+  return ret;
+}
+
+ObBackupSetDecryptionStmt::ObBackupSetDecryptionStmt() : ObSystemCmdStmt(stmt::T_BACKUP_SET_DECRYPTION)
+{
+  passwd_array_[0] = '\0';
+  pos_ = 0;
+}
+
+int ObBackupSetDecryptionStmt::add_passwd(const ObString& passwd)
+{
+  int ret = OB_SUCCESS;
+  char passwd_buf[OB_MAX_PASSWORD_LENGTH];
+  ObString encrypted_passwd;
+  encrypted_passwd.assign_ptr(passwd_buf, sizeof(passwd_buf));
+
+  if (pos_ != 0) {
+    if (FAILEDx(databuff_printf(passwd_array_, sizeof(passwd_array_), pos_, ","))) {
+      COMMON_LOG(WARN, "failed to comma", K(ret), K_(pos), K_(passwd_array));
+    }
+  }
+
+  if (FAILEDx(ObEncryptedHelper::encrypt_passwd_to_stage2(passwd, encrypted_passwd))) {
+    COMMON_LOG(WARN, "failed to encrypted passwd", K(ret), K(passwd));
+  } else if (OB_FAIL(databuff_printf(passwd_array_,
+                 sizeof(passwd_array_),
+                 pos_,
+                 "%.*s",
+                 encrypted_passwd.length(),
+                 encrypted_passwd.ptr()))) {
+    COMMON_LOG(WARN, "failed to add passwd", K(ret), K_(pos), K_(passwd_array));
+  }
+
+  COMMON_LOG(INFO, "add passwd", K(passwd), K(encrypted_passwd), K_(passwd_array));
+
+  return ret;
+}

src/sql/resolver/cmd/ob_bootstrap_resolver.cpp

@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+#include "sql/resolver/cmd/ob_bootstrap_resolver.h"
+#include "sql/resolver/cmd/ob_bootstrap_stmt.h"
+#include "sql/parser/ob_item_type.h"
+#include "share/ob_zone_info.h"
+
+namespace oceanbase {
+using namespace common;
+using namespace share;
+namespace sql {
+ObBootstrapResolver::ObBootstrapResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
+{}
+
+ObBootstrapResolver::~ObBootstrapResolver()
+{}
+
+int ObBootstrapResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObBootstrapStmt* bootstrap_stmt = NULL;
+  if (OB_ISNULL(allocator_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("allocator_ is NULL", K(ret));
+  } else if (OB_UNLIKELY(T_BOOTSTRAP != parse_tree.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("type_ of parse_tree is not T_BOOTSTRAP", K(parse_tree.type_), K(ret));
+  } else if (OB_UNLIKELY(NULL == (bootstrap_stmt = create_stmt<ObBootstrapStmt>()))) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("create ObBootstrapStmt failed", K(ret));
+  } else {
+    stmt_ = bootstrap_stmt;
+  }
+  if (OB_SUCC(ret)) {
+    ParseNode* server_infos = parse_tree.children_[0];
+    if (OB_ISNULL(server_infos)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("server_infos is NULL", K(ret));
+    } else if (OB_UNLIKELY(T_SERVER_INFO_LIST != server_infos->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("server_infos type is not T_SERVER_INFO_LIST", K(server_infos->type_), K(ret));
+    } else if (OB_ISNULL(server_infos->children_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("server_infos children is NULL", K(ret));
+    } else {
+      obrpc::ObServerInfoList& server_list = bootstrap_stmt->get_server_info_list();
+      for (int64_t i = 0; OB_SUCC(ret) && i < server_infos->num_child_; ++i) {
+        ParseNode* server_info_node = server_infos->children_[i];
+        if (OB_ISNULL(server_info_node)) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("server_info_node is NULL", K(ret));
+        } else if (OB_UNLIKELY(T_SERVER_INFO != server_info_node->type_)) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("server_info_node type is not T_SERVER_INFO", K(server_info_node->type_), K(ret));
+        } else if (OB_ISNULL(server_info_node->children_[1])) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("first child of server_info_node is NULL", K(ret));
+        } else if (OB_ISNULL(server_info_node->children_[2])) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("secord child of server_info_node is NULL", K(ret));
+        } else {
+          ObString zone_name;
+          ObString zone_str;
+          ObString region_name;
+          ObString region_str;
+          ObString ip_port;
+          obrpc::ObServerInfo server_info;
+
+          if (NULL == server_info_node->children_[0]) {
+            region_str.assign_ptr(DEFAULT_REGION_NAME, static_cast<int32_t>(strlen(DEFAULT_REGION_NAME)));
+          } else {
+            region_str.assign_ptr(server_info_node->children_[0]->str_value_,
+                static_cast<int32_t>(server_info_node->children_[0]->str_len_));
+          }
+          zone_str.assign_ptr(server_info_node->children_[1]->str_value_,
+              static_cast<int32_t>(server_info_node->children_[1]->str_len_));
+          ip_port.assign_ptr(server_info_node->children_[2]->str_value_,
+              static_cast<int32_t>(server_info_node->children_[2]->str_len_));
+          if (OB_FAIL(ob_write_string(*allocator_, region_str, region_name))) {
+            LOG_WARN("write region name failed", K(region_str), K(ret));
+          } else if (OB_FAIL(server_info.region_.assign(region_name))) {
+            LOG_WARN("assign region name failed", K(region_str), K(region_name), K(ret));
+          } else if (OB_FAIL(ob_write_string(*allocator_, zone_str, zone_name))) {
+            LOG_WARN("write zone name failed", K(zone_str), K(ret));
+          } else if (OB_FAIL(server_info.zone_.assign(zone_name))) {
+            LOG_WARN("assign zone name failed", K(zone_str), K(zone_name), K(ret));
+          } else if (OB_FAIL(server_info.server_.parse_from_string(ip_port))) {
+            LOG_WARN("Invalid server address", "ip:port", ip_port, K(ret));
+          } else if (OB_FAIL(server_list.push_back(server_info))) {
+            LOG_WARN("push back server info failed", K(ret));
+          } else {
+          }
+        }
+      }
+    }
+  }
+  if (OB_SUCC(ret)) {
+    ParseNode* cluster_type_node = parse_tree.children_[1];
+    ObClusterType type = PRIMARY_CLUSTER;
+    if (OB_ISNULL(cluster_type_node)) {
+      // nothing todo
+    } else if (T_CLUSTER_TYPE != cluster_type_node->type_ || 1 != cluster_type_node->num_child_ ||
+               OB_ISNULL(cluster_type_node->children_[0])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("invalid node", K(ret), K(cluster_type_node));
+    } else {
+      LOG_INFO("resolve cluster type", K(type));
+      if (0 == cluster_type_node->children_[0]->value_) {
+        type = PRIMARY_CLUSTER;
+      } else {
+        type = STANDBY_CLUSTER;
+      }
+    }
+    if (OB_FAIL(ret)) {
+    } else {
+      bootstrap_stmt->set_cluster_type(type);
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    ParseNode* primary_rootservice_node = parse_tree.children_[2];
+    if (PRIMARY_CLUSTER == bootstrap_stmt->get_cluster_type()) {
+      if (OB_ISNULL(primary_rootservice_node)) {
+        // nothing todo
+      } else {
+        ret = OB_ERR_PARSE_SQL;
+        LOG_WARN("parse error, primary cluster should not have primary_rootservice_node", KR(ret));
+      }
+    } else if (STANDBY_CLUSTER == bootstrap_stmt->get_cluster_type()) {
+      ObString primary_rootservice_list;
+      ObString primary_rootservice_list_str;
+      ObArray<ObString> addr_string;
+      ObArray<ObAddr> addr_array;
+      int64_t primary_cluster_id = OB_INVALID_ID;
+      if (OB_ISNULL(primary_rootservice_node) || 2 != primary_rootservice_node->num_child_ ||
+          OB_ISNULL(primary_rootservice_node->children_[0]) || OB_ISNULL(primary_rootservice_node->children_[1])) {
+        ret = OB_ERR_PARSE_SQL;
+        LOG_WARN("parse error, standby cluster should have primary_rootservice_list node", KR(ret));
+      } else {
+        primary_cluster_id = primary_rootservice_node->children_[0]->value_;
+        primary_rootservice_list_str.assign_ptr(primary_rootservice_node->children_[1]->str_value_,
+            static_cast<int32_t>(primary_rootservice_node->children_[1]->str_len_));
+        if (OB_FAIL(ob_write_string(*allocator_, primary_rootservice_list_str, primary_rootservice_list))) {
+          LOG_WARN("fail to write string", KR(ret));
+        } else {
+          ObString trimed_string = primary_rootservice_list.trim();
+          if (OB_FAIL(split_on(trimed_string, ',', addr_string))) {
+            LOG_WARN("fail to split string", KR(ret), K(trimed_string));
+          } else {
+            for (int64_t i = 0; i < addr_string.count() && OB_SUCC(ret); i++) {
+              ObAddr addr;
+              if (OB_FAIL(addr.parse_from_string(addr_string.at(i)))) {
+                LOG_WARN("fail to parse from string", KR(ret), K(i), "string", addr_string.at(i));
+              } else if (OB_FAIL(addr_array.push_back(addr))) {
+                LOG_WARN("fail to push back", KR(ret), K(addr));
+              }
+            }  // end for
+          }    // end else
+        }
+        if (OB_FAIL(ret)) {
+        } else if (OB_FAIL(bootstrap_stmt->set_primary_rs_list(addr_array))) {
+          LOG_WARN("fail to set primary rs list", KR(ret));
+        } else {
+          bootstrap_stmt->set_primary_cluster_id(primary_cluster_id);
+        }
+      }
+    } else {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("get invalid cluster type", KR(ret), "cluster_type", bootstrap_stmt->get_cluster_type());
+    }
+  }
+  return ret;
+}
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_bootstrap_resolver.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_BOOTSTRAP_RESOLVER_
+#define OCEANBASE_SQL_RESOLVER_CMD_BOOTSTRAP_RESOLVER_
+
+#include "sql/resolver/cmd/ob_system_cmd_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+class ObBootstrapResolver : public ObSystemCmdResolver {
+  public:
+  explicit ObBootstrapResolver(ObResolverParams& params);
+  virtual ~ObBootstrapResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObBootstrapResolver);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_BOOTSTRAP_RESOLVER_ */

src/sql/resolver/cmd/ob_bootstrap_stmt.h

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_BOOTSTRAP_STMT_
+#define OCEANBASE_SQL_RESOLVER_CMD_BOOTSTRAP_STMT_
+
+#include "share/ob_rpc_struct.h"
+#include "sql/resolver/cmd/ob_system_cmd_stmt.h"
+
+namespace oceanbase {
+namespace sql {
+class ObBootstrapStmt : public ObSystemCmdStmt {
+  public:
+  ObBootstrapStmt() : ObSystemCmdStmt(stmt::T_BOOTSTRAP), bootstrap_arg_()
+  {}
+  explicit ObBootstrapStmt(common::ObIAllocator* name_pool) : ObSystemCmdStmt(name_pool, stmt::T_BOOTSTRAP)
+  {}
+  virtual ~ObBootstrapStmt()
+  {}
+
+  void set_cluster_type(common::ObClusterType type)
+  {
+    bootstrap_arg_.cluster_type_ = type;
+  }
+  int set_primary_rs_list(const common::ObIArray<common::ObAddr>& rs_list)
+  {
+    return bootstrap_arg_.primary_rs_list_.assign(rs_list);
+  }
+  common::ObClusterType get_cluster_type() const
+  {
+    return bootstrap_arg_.cluster_type_;
+  }
+  obrpc::ObServerInfoList& get_server_info_list()
+  {
+    return bootstrap_arg_.server_list_;
+  }
+  void set_primary_cluster_id(const int64_t primary_cluster_id)
+  {
+    bootstrap_arg_.primary_cluster_id_ = primary_cluster_id;
+  }
+  TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(bootstrap_arg));
+
+  public:
+  obrpc::ObBootstrapArg bootstrap_arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObBootstrapStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_OB_BOOTSTRAP_STMT_ */

src/sql/resolver/cmd/ob_clear_balance_task_stmt.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_CLEAR_BALANCE_TASK_H
+#define OCEANBASE_SQL_RESOLVER_CMD_CLEAR_BALANCE_TASK_H
+#include "sql/resolver/cmd/ob_system_cmd_stmt.h"
+#include "share/ob_rpc_struct.h"
+namespace oceanbase {
+namespace sql {
+class ObClearBalanceTaskStmt : public ObSystemCmdStmt {
+  public:
+  ObClearBalanceTaskStmt() : ObSystemCmdStmt(stmt::T_CLEAR_BALANCE_TASK), arg_()
+  {}
+  explicit ObClearBalanceTaskStmt(common::ObIAllocator* name_pool)
+      : ObSystemCmdStmt(name_pool, stmt::T_CLEAR_BALANCE_TASK), arg_()
+  {}
+
+  virtual ~ObClearBalanceTaskStmt()
+  {}
+
+  common::ObIArray<uint64_t>& get_tenant_ids()
+  {
+    return arg_.tenant_ids_;
+  }
+  common::ObIArray<ObZone>& get_zone_names()
+  {
+    return arg_.zone_names_;
+  }
+  void set_type(const obrpc::ObAdminClearBalanceTaskArg::TaskType type)
+  {
+    arg_.type_ = type;
+  }
+  const obrpc::ObAdminClearBalanceTaskArg& get_rpc_arg() const
+  {
+    return arg_;
+  }
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObClearBalanceTaskStmt);
+  obrpc::ObAdminClearBalanceTaskArg arg_;
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif

src/sql/resolver/cmd/ob_cmd_resolver.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_CMD_RESOLVER_
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_CMD_RESOLVER_
+
+#include "share/schema/ob_table_schema.h"
+#include "sql/resolver/ob_stmt_resolver.h"
+#include "sql/resolver/ob_resolver_define.h"
+namespace oceanbase {
+namespace sql {
+class ObCMDResolver : public ObStmtResolver {
+  public:
+  explicit ObCMDResolver(ObResolverParams& params) : ObStmtResolver(params)
+  {}
+  virtual ~ObCMDResolver()
+  {}
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObCMDResolver);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_OB_CMD_RESOLVER_*/

src/sql/resolver/cmd/ob_cmd_stmt.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_CMD_STMT_
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_CMD_STMT_
+
+#include "share/ob_rpc_struct.h"
+#include "sql/resolver/ob_stmt.h"
+#include "sql/resolver/ob_cmd.h"
+namespace oceanbase {
+namespace sql {
+class ObCMDStmt : public ObStmt, public ObICmd {
+  public:
+  ObCMDStmt(common::ObIAllocator* name_pool, stmt::StmtType type) : ObStmt(name_pool, type)
+  {}
+  explicit ObCMDStmt(stmt::StmtType type) : ObStmt(type)
+  {}
+  virtual ~ObCMDStmt()
+  {}
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObCMDStmt);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_OB_CMD_STMT_ */

src/sql/resolver/cmd/ob_create_restore_point_resolver.cpp

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+
+#include "sql/resolver/cmd/ob_create_restore_point_resolver.h"
+#include "sql/resolver/cmd/ob_create_restore_point_stmt.h"
+#include "sql/resolver/expr/ob_raw_expr_util.h"
+#include "sql/resolver/cmd/ob_variable_set_resolver.h"
+
+namespace oceanbase {
+using namespace common;
+using namespace share::schema;
+namespace sql {
+
+/**
+ *  CREATE RESTORE POINT restore_point_name
+ *
+ */
+
+ObCreateRestorePointResolver::ObCreateRestorePointResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
+{}
+
+ObCreateRestorePointResolver::~ObCreateRestorePointResolver()
+{}
+
+int ObCreateRestorePointResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObCreateRestorePointStmt* mystmt = NULL;
+
+  if (OB_UNLIKELY(T_CREATE_RESTORE_POINT != parse_tree.type_) || OB_ISNULL(parse_tree.children_) ||
+      OB_UNLIKELY(1 != parse_tree.num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("invalid param", K(parse_tree.type_), K(parse_tree.num_child_), K(parse_tree.children_), K(ret));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObCreateRestorePointStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create select stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  if (OB_SUCC(ret) && ObSchemaChecker::is_ora_priv_check()) {
+    OZ(schema_checker_->check_ora_ddl_priv(session_info_->get_effective_tenant_id(),
+        session_info_->get_priv_user_id(),
+        ObString("") /*database_name*/,
+        stmt::T_CREATE_RESTORE_POINT,
+        session_info_->get_enable_role_array()));
+  }
+
+  /* tenant name */
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(T_IDENT != parse_tree.children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid parse_tree", K(ret));
+    } else {
+      ObString restore_point_name;
+      restore_point_name.assign_ptr(
+          (char*)(parse_tree.children_[0]->str_value_), static_cast<int32_t>(parse_tree.children_[0]->str_len_));
+      if (restore_point_name.length() >= OB_MAX_RESERVED_POINT_NAME_LENGTH) {
+        ret = OB_ERR_TOO_LONG_IDENT;
+        LOG_USER_ERROR(OB_ERR_TOO_LONG_IDENT, restore_point_name.length(), restore_point_name.ptr());
+      } else {
+        mystmt->set_restore_point_name(restore_point_name);
+      }
+    }
+  }
+
+  return ret;
+}
+
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_create_restore_point_resolver.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_CREATE_RESTORE_POINT_RESOLVER_
+#define OCEANBASE_CREATE_RESTORE_POINT_RESOLVER_ 1
+
+#include "sql/resolver/cmd/ob_system_cmd_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+class ObCreateRestorePointResolver : public ObSystemCmdResolver {
+  public:
+  explicit ObCreateRestorePointResolver(ObResolverParams& params);
+  virtual ~ObCreateRestorePointResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObCreateRestorePointResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+}  // end namespace sql
+}  // end namespace oceanbase
+
+#endif /* OCEANBASE_CREATE_RESTORE_POINT_RESOLVER_ */

src/sql/resolver/cmd/ob_create_restore_point_stmt.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_OB_CREATE_RESTORE_POINT_STMT_H_
+#define OCEANBASE_SQL_OB_CREATE_RESTORE_POINT_STMT_H_
+
+#include "share/ob_rpc_struct.h"
+#include "sql/resolver/ob_stmt_resolver.h"
+#include "sql/resolver/cmd/ob_system_cmd_stmt.h"
+#include "sql/resolver/cmd/ob_variable_set_stmt.h"
+
+namespace oceanbase {
+namespace sql {
+class ObCreateRestorePointStmt : public ObSystemCmdStmt {
+  public:
+  explicit ObCreateRestorePointStmt(common::ObIAllocator* name_pool)
+      : ObSystemCmdStmt(name_pool, stmt::T_CREATE_RESTORE_POINT), create_restore_point_arg_(), restore_point_name_()
+  {}
+  ObCreateRestorePointStmt()
+      : ObSystemCmdStmt(stmt::T_CREATE_RESTORE_POINT), create_restore_point_arg_(), restore_point_name_()
+  {}
+  virtual ~ObCreateRestorePointStmt()
+  {}
+  inline obrpc::ObCreateRestorePointArg& get_create_restore_point_arg()
+  {
+    return create_restore_point_arg_;
+  }
+
+  void set_tenant_id(const int64_t tenant_id)
+  {
+    create_restore_point_arg_.tenant_id_ = tenant_id;
+  }
+  void set_restore_point_name(const common::ObString& restore_point_name)
+  {
+    restore_point_name_ = restore_point_name;
+    create_restore_point_arg_.name_ = restore_point_name;
+  }
+  ObString get_restore_point_name()
+  {
+    return restore_point_name_;
+  }
+
+  private:
+  obrpc::ObCreateRestorePointArg create_restore_point_arg_;
+  ObString restore_point_name_;
+  DISALLOW_COPY_AND_ASSIGN(ObCreateRestorePointStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif  // OCEANBASE_SQL_OB_CREATE_TENANT_STMT_H_

src/sql/resolver/cmd/ob_drop_restore_point_resolver.cpp

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+
+#include "sql/resolver/cmd/ob_drop_restore_point_resolver.h"
+#include "sql/resolver/cmd/ob_drop_restore_point_stmt.h"
+#include "sql/resolver/expr/ob_raw_expr_util.h"
+#include "sql/resolver/cmd/ob_variable_set_resolver.h"
+
+namespace oceanbase {
+using namespace common;
+using namespace share::schema;
+namespace sql {
+
+/**
+ *  DROP RESTORE POINT restore_point_name
+ *
+ */
+
+ObDropRestorePointResolver::ObDropRestorePointResolver(ObResolverParams& params) : ObSystemCmdResolver(params)
+{}
+
+ObDropRestorePointResolver::~ObDropRestorePointResolver()
+{}
+
+int ObDropRestorePointResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObDropRestorePointStmt* mystmt = NULL;
+
+  if (OB_UNLIKELY(T_DROP_RESTORE_POINT != parse_tree.type_) || OB_ISNULL(parse_tree.children_) ||
+      OB_UNLIKELY(1 != parse_tree.num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("invalid param", K(parse_tree.type_), K(parse_tree.num_child_), K(parse_tree.children_), K(ret));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObDropRestorePointStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create select stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  if (OB_SUCC(ret) && ObSchemaChecker::is_ora_priv_check()) {
+    OZ(schema_checker_->check_ora_ddl_priv(session_info_->get_effective_tenant_id(),
+        session_info_->get_priv_user_id(),
+        ObString("") /*database_name*/,
+        stmt::T_DROP_RESTORE_POINT,
+        session_info_->get_enable_role_array()));
+  }
+
+  /* tenant name */
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(T_IDENT != parse_tree.children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid parse_tree", K(ret));
+    } else {
+      ObString restore_point_name;
+      restore_point_name.assign_ptr(
+          (char*)(parse_tree.children_[0]->str_value_), static_cast<int32_t>(parse_tree.children_[0]->str_len_));
+      if (restore_point_name.length() >= OB_MAX_RESERVED_POINT_NAME_LENGTH) {
+        ret = OB_ERR_TOO_LONG_IDENT;
+        LOG_USER_ERROR(OB_ERR_TOO_LONG_IDENT, restore_point_name.length(), restore_point_name.ptr());
+      } else {
+        mystmt->set_restore_point_name(restore_point_name);
+      }
+    }
+  }
+
+  return ret;
+}
+
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_drop_restore_point_resolver.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_DROP_RESTORE_POINT_RESOLVER_
+#define OCEANBASE_DROP_RESTORE_POINT_RESOLVER_ 1
+
+#include "sql/resolver/cmd/ob_system_cmd_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+class ObDropRestorePointResolver : public ObSystemCmdResolver {
+  public:
+  explicit ObDropRestorePointResolver(ObResolverParams& params);
+  virtual ~ObDropRestorePointResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObDropRestorePointResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+}  // end namespace sql
+}  // end namespace oceanbase
+
+#endif /* OCEANBASE_DROP_RESTORE_POINT_RESOLVER_ */

src/sql/resolver/cmd/ob_drop_restore_point_stmt.h

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_OB_DROP_RESTORE_POINT_STMT_H_
+#define OCEANBASE_SQL_OB_DROP_RESTORE_POINT_STMT_H_
+
+#include "share/ob_rpc_struct.h"
+#include "sql/resolver/ob_stmt_resolver.h"
+#include "sql/resolver/cmd/ob_system_cmd_stmt.h"
+#include "sql/resolver/cmd/ob_variable_set_stmt.h"
+
+namespace oceanbase {
+namespace sql {
+class ObDropRestorePointStmt : public ObSystemCmdStmt {
+  public:
+  explicit ObDropRestorePointStmt(common::ObIAllocator* name_pool)
+      : ObSystemCmdStmt(name_pool, stmt::T_DROP_RESTORE_POINT), drop_restore_point_arg_(), restore_point_name_()
+  {}
+  ObDropRestorePointStmt()
+      : ObSystemCmdStmt(stmt::T_DROP_RESTORE_POINT), drop_restore_point_arg_(), restore_point_name_()
+  {}
+  virtual ~ObDropRestorePointStmt()
+  {}
+  inline obrpc::ObDropRestorePointArg& get_drop_restore_point_arg()
+  {
+    return drop_restore_point_arg_;
+  }
+  void set_tenant_id(const int64_t tenant_id)
+  {
+    drop_restore_point_arg_.tenant_id_ = tenant_id;
+  }
+  void set_restore_point_name(const common::ObString& restore_point_name)
+  {
+    restore_point_name_ = restore_point_name;
+    drop_restore_point_arg_.name_ = restore_point_name;
+  }
+  ObString get_restore_point_name()
+  {
+    return restore_point_name_;
+  }
+
+  private:
+  obrpc::ObDropRestorePointArg drop_restore_point_arg_;
+  ObString restore_point_name_;
+  DISALLOW_COPY_AND_ASSIGN(ObDropRestorePointStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif  // OCEANBASE_SQL_OB_CREATE_TENANT_STMT_H_

src/sql/resolver/cmd/ob_empty_query_resolver.cpp

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_ENG
+#include "sql/resolver/cmd/ob_empty_query_resolver.h"
+#include "sql/resolver/cmd/ob_empty_query_stmt.h"
+
+namespace oceanbase {
+using namespace oceanbase::common;
+namespace sql {
+int ObEmptyQueryResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObEmptyQueryStmt* empty_query_stmt = NULL;
+  if (T_EMPTY_QUERY != parse_tree.type_) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("parser tree type is not T_EMPTY_QUERY", K(parse_tree.type_), K(ret));
+  } else if (0 == parse_tree.value_) {
+    // empty query with no comment
+    ret = OB_ERR_EMPTY_QUERY;
+
+  } else if (OB_ISNULL(empty_query_stmt = create_stmt<ObEmptyQueryStmt>())) {
+    ret = OB_SQL_RESOLVER_NO_MEMORY;
+    LOG_WARN("failed to create empty query stmt", K(ret));
+  } else {
+  }
+  return ret;
+}
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_empty_query_resolver.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_EMPTY_QUERY_RESOLVER_H_
+#define OCEANBASE_SQL_RESOLVER_CMD_EMPTY_QUERY_RESOLVER_H_
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+namespace oceanbase {
+namespace sql {
+class ObEmptyQueryResolver : public ObCMDResolver {
+  public:
+  explicit ObEmptyQueryResolver(ObResolverParams& params) : ObCMDResolver(params)
+  {}
+  virtual ~ObEmptyQueryResolver()
+  {}
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObEmptyQueryResolver);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif /*OCEANBASE_RESOLVER_CMD_EMPTY_QUERY_RESOLVER_H_*/

src/sql/resolver/cmd/ob_empty_query_stmt.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_EMPTY_QUERY_STMT_H_
+#define OCEANBASE_SQL_RESOLVER_EMPTY_QUERY_STMT_H_
+
+#include "sql/resolver/ob_stmt.h"
+#include "sql/resolver/cmd/ob_cmd_stmt.h"
+namespace oceanbase {
+namespace sql {
+class ObEmptyQueryStmt : public ObCMDStmt {
+  public:
+  ObEmptyQueryStmt() : ObCMDStmt(stmt::T_EMPTY_QUERY)
+  {}
+
+  virtual ~ObEmptyQueryStmt()
+  {}
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObEmptyQueryStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif /*OCEANBASE_SQL_RESOLVER_EMPTY_QUERY_STMT_H_*/

src/sql/resolver/cmd/ob_kill_resolver.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+#include "sql/resolver/cmd/ob_kill_resolver.h"
+#include "sql/resolver/cmd/ob_kill_stmt.h"
+#include "sql/resolver/ob_resolver_utils.h"
+namespace oceanbase {
+using namespace oceanbase::common;
+namespace sql {
+int ObKillResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObKillStmt* kill_stmt = NULL;
+  ObRawExpr* tmp_expr = NULL;
+  if (OB_UNLIKELY(parse_tree.type_ != T_KILL || parse_tree.num_child_ != 2 || NULL == parse_tree.children_[0] ||
+                  parse_tree.children_[0]->type_ != T_BOOL || NULL == parse_tree.children_[1])) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid parse tree", K(ret), K(parse_tree.type_), K(parse_tree.num_child_));
+  } else if (OB_UNLIKELY(NULL == (kill_stmt = create_stmt<ObKillStmt>()))) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("failed to create kill stmt");
+  } else if (OB_FAIL(ObResolverUtils::resolve_const_expr(params_, *(parse_tree.children_[1]), tmp_expr, NULL))) {
+    LOG_WARN("resolve const expr failed", K(ret));
+  } else {
+    kill_stmt->set_is_query(1 == parse_tree.children_[0]->value_);
+    kill_stmt->set_value_expr(tmp_expr);
+  }
+  return ret;
+}
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_kill_resolver.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_KILL_RESOLVER_H
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_KILL_RESOLVER_H
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+namespace oceanbase {
+namespace sql {
+class ObKillResolver : public ObCMDResolver {
+  public:
+  explicit ObKillResolver(ObResolverParams& params) : ObCMDResolver(params)
+  {}
+  virtual ~ObKillResolver()
+  {}
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObKillResolver);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif

src/sql/resolver/cmd/ob_kill_stmt.h

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OB_KILL_STMT_H_
+#define OB_KILL_STMT_H_
+
+#include "sql/resolver/cmd/ob_cmd_stmt.h"
+namespace oceanbase {
+namespace sql {
+class ObKillStmt : public ObCMDStmt {
+  public:
+  ObKillStmt() : ObCMDStmt(stmt::T_KILL), is_query_(false), value_expr_(NULL)
+  {}
+  virtual ~ObKillStmt()
+  {}
+
+  inline void set_is_query(bool is_query)
+  {
+    is_query_ = is_query;
+  }
+  inline void set_value_expr(ObRawExpr* value_expr)
+  {
+    value_expr_ = value_expr;
+  }
+  inline ObRawExpr* get_value_expr() const
+  {
+    return value_expr_;
+  }
+  inline bool is_query() const
+  {
+    return is_query_;
+  }
+
+  private:
+  bool is_query_;
+  ObRawExpr* value_expr_;
+  DISALLOW_COPY_AND_ASSIGN(ObKillStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif

src/sql/resolver/cmd/ob_load_data_resolver.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_LOAD_DATA_RESOLVER_H
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_LOAD_DATA_RESOLVER_H
+#include "lib/ob_define.h"
+#include "sql/resolver/expr/ob_raw_expr_util.h"
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+namespace oceanbase {
+namespace sql {
+class ObLoadDataStmt;
+struct ObDataInFileStruct;
+
+class ObLoadDataResolver : public ObCMDResolver {
+  public:
+  explicit ObLoadDataResolver(ObResolverParams& params) : ObCMDResolver(params), current_scope_(T_LOAD_DATA_SCOPE)
+  {}
+  virtual ~ObLoadDataResolver()
+  {}
+  virtual int resolve(const ParseNode& parse_tree);
+  int resolve_field_node(const ParseNode& node, const common::ObNameCaseMode case_mode, ObLoadDataStmt& load_stmt);
+  int resolve_user_vars_node(const ParseNode& node, ObLoadDataStmt& load_stmt);
+  int resolve_field_or_var_list_node(
+      const ParseNode& node, const common::ObNameCaseMode case_mode, ObLoadDataStmt& load_stmt);
+  int resolve_empty_field_or_var_list_node(ObLoadDataStmt& load_stmt);
+  int resolve_set_clause(const ParseNode& node, const common::ObNameCaseMode case_mode, ObLoadDataStmt& load_stmt);
+  int resolve_each_set_node(const ParseNode& node, const common::ObNameCaseMode case_mode, ObLoadDataStmt& load_stmt);
+  int resolve_char_node(const ParseNode& node, int32_t& single_char);
+  int resolve_string_node(const ParseNode& node, common::ObString& target_str);
+  int resolve_field_list_node(const ParseNode& node, ObDataInFileStruct& data_struct_in_file);
+  int resolve_line_list_node(const ParseNode& node, ObDataInFileStruct& data_struct_in_file);
+  int resolve_sys_vars(common::ObIArray<ObVarInfo>& sys_vars);
+  int resolve_default_func(ObRawExpr*& expr);
+  int resolve_default_expr(ObRawExpr*& expr, ObLoadDataStmt& load_stmt, uint64_t column_id);
+  int resolve_subquery_info(common::ObIArray<ObSubQueryInfo>& subquery_info);
+  int build_column_ref_expr(ObQualifiedName& q_name, ObRawExpr*& col_expr);
+  int resolve_column_ref_expr(common::ObIArray<ObQualifiedName>& columns, ObRawExpr*& expr);
+  int check_if_table_exists(uint64_t tenant_id, const common::ObString& db_name, const common::ObString& table_name,
+      bool cte_table_fisrt, uint64_t& table_id);
+  int validate_stmt(ObLoadDataStmt* stmt);
+  int resolve_hints(const ParseNode& node);
+
+  private:
+  enum ParameterEnum {
+    ENUM_OPT_LOCAL = 0,
+    ENUM_FILE_NAME,
+    ENUM_DUPLICATE_ACTION,
+    ENUM_TABLE_NAME,
+    ENUM_OPT_CHARSET,
+    ENUM_OPT_FIELD,
+    ENUM_OPT_LINE,
+    ENUM_OPT_IGNORE_ROWS,
+    ENUM_OPT_FIELD_OR_VAR,
+    ENUM_OPT_SET_FIELD,
+    ENUM_OPT_HINT,
+    ENUM_TOTAL_COUNT
+  };
+  ObStmtScope current_scope_;
+  DISALLOW_COPY_AND_ASSIGN(ObLoadDataResolver);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif

src/sql/resolver/cmd/ob_load_data_stmt.cpp

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+
+#include "ob_load_data_stmt.h"
+namespace oceanbase {
+namespace sql {
+
+const char* ObDataInFileStruct::DEFAULT_LINE_TERM_STR = "\n";
+const char* ObDataInFileStruct::DEFAULT_LINE_BEGIN_STR = "";
+const char* ObDataInFileStruct::DEFAULT_FIELD_TERM_STR = "\t";
+const char* ObDataInFileStruct::DEFAULT_FIELD_ESCAPED_STR = "\\";
+const char* ObDataInFileStruct::DEFAULT_FIELD_ENCLOSED_STR = "";
+const int64_t ObDataInFileStruct::DEFAULT_FIELD_ESCAPED_CHAR = static_cast<int64_t>('\\');
+const int64_t ObDataInFileStruct::DEFAULT_FIELD_ENCLOSED_CHAR = INT64_MAX;
+const bool ObDataInFileStruct::DEFAULT_OPTIONAL_ENCLOSED = false;
+
+int ObLoadDataStmt::add_column_item(ColumnItem& item)
+{
+  int ret = OB_SUCCESS;
+  if (OB_FAIL(column_items_.push_back(item))) {
+    LOG_WARN("push column item failed", K(ret));
+  }
+  return ret;
+}
+
+ColumnItem* ObLoadDataStmt::get_column_item_by_idx(uint64_t column_id)
+{
+  ColumnItem* tar_item = NULL;
+  for (int64_t i = 0; i < column_items_.count(); ++i) {
+    ColumnItem& item = column_items_.at(i);
+    if (item.column_id_ == column_id) {
+      tar_item = &item;
+      break;
+    }
+  }
+  return tar_item;
+}
+
+int ObLoadDataHint::get_value(IntHintItem item, int64_t& value) const
+{
+  int ret = OB_SUCCESS;
+  if (item >= TOTAL_INT_ITEM || item < 0) {
+    ret = OB_INVALID_ARGUMENT;
+  } else {
+    value = integer_values_[item];
+  }
+  return ret;
+}
+
+int ObLoadDataHint::set_value(IntHintItem item, int64_t value)
+{
+  int ret = OB_SUCCESS;
+  if (item >= TOTAL_INT_ITEM || item < 0) {
+    ret = OB_INVALID_ARGUMENT;
+  } else {
+    integer_values_[item] = value;
+  }
+  return ret;
+}
+
+int ObLoadDataHint::get_value(StringHintItem item, ObString& value) const
+{
+  int ret = OB_SUCCESS;
+  if (item >= TOTAL_STRING_ITEM || item < 0) {
+    ret = OB_INVALID_ARGUMENT;
+  } else {
+    value = string_values_[item];
+  }
+  return ret;
+}
+
+int ObLoadDataHint::set_value(StringHintItem item, const ObString& value)
+{
+  int ret = OB_SUCCESS;
+  if (item >= TOTAL_STRING_ITEM || item < 0) {
+    ret = OB_INVALID_ARGUMENT;
+  } else {
+    string_values_[item] = value;
+  }
+  return ret;
+}
+
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_load_data_stmt.h

@@ -0,0 +1,249 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OB_LOAD_DATA_STMT_H_
+#define OB_LOAD_DATA_STMT_H_
+
+#include "sql/resolver/cmd/ob_cmd_stmt.h"
+#include "sql/resolver/dml/ob_dml_stmt.h"
+namespace oceanbase {
+namespace sql {
+
+enum class ObLoadDupActionType {
+  LOAD_STOP_ON_DUP = 0,  // stop when going to insert duplicated key
+  LOAD_REPLACE,          // replace into table when the rowkey is already existed
+  LOAD_IGNORE,           // skip this line, when the rowkey is already existed
+  LOAD_INVALID_MODE
+};
+
+enum class ObLoadFileLocation {
+  SERVER_DISK = 0,
+  CLIENT_DISK,
+  OSS,
+};
+
+struct ObLoadArgument {
+  ObLoadArgument()
+      : load_file_storage_(ObLoadFileLocation::SERVER_DISK),
+        is_default_charset_(true),
+        ignore_rows_(0),
+        dupl_action_(ObLoadDupActionType::LOAD_STOP_ON_DUP),
+        tenant_id_(OB_INVALID_INDEX_INT64),
+        database_id_(OB_INVALID_INDEX_INT64),
+        table_id_(OB_INVALID_INDEX_INT64),
+        is_csv_format_(false)
+
+  {}
+
+  TO_STRING_KV(K_(load_file_storage), K_(is_default_charset), K_(ignore_rows), K_(dupl_action), K_(charset),
+      K_(file_name), K_(access_info), K_(database_name), K_(table_name), K_(combined_name), K_(tenant_id),
+      K_(database_id), K_(table_id), K_(is_csv_format), K_(full_file_path));
+
+  void assign(const ObLoadArgument& other)
+  {
+    load_file_storage_ = other.load_file_storage_;
+    is_default_charset_ = other.is_default_charset_;
+    ignore_rows_ = other.ignore_rows_;
+    dupl_action_ = other.dupl_action_;
+    charset_ = other.charset_;
+    file_name_ = other.file_name_;
+    access_info_ = other.access_info_;
+    database_name_ = other.database_name_;
+    table_name_ = other.table_name_;
+    combined_name_ = other.combined_name_;
+    tenant_id_ = other.tenant_id_;
+    database_id_ = other.database_id_;
+    table_id_ = other.table_id_;
+    is_csv_format_ = other.is_csv_format_;
+    full_file_path_ = other.full_file_path_;
+  }
+
+  ObLoadFileLocation load_file_storage_;
+  bool is_default_charset_;
+  int64_t ignore_rows_;
+  ObLoadDupActionType dupl_action_;
+  common::ObString charset_;
+  common::ObString file_name_;
+  common::ObString access_info_;
+  common::ObString database_name_;
+  common::ObString table_name_;
+  common::ObString combined_name_;
+  uint64_t tenant_id_;
+  uint64_t database_id_;
+  uint64_t table_id_;
+  bool is_csv_format_;
+  common::ObString full_file_path_;
+};
+
+struct ObDataInFileStruct {
+  static const char* DEFAULT_LINE_TERM_STR;
+  static const char* DEFAULT_LINE_BEGIN_STR;
+  static const char* DEFAULT_FIELD_TERM_STR;
+  static const char* DEFAULT_FIELD_ESCAPED_STR;
+  static const char* DEFAULT_FIELD_ENCLOSED_STR;
+  static const int64_t DEFAULT_FIELD_ESCAPED_CHAR;
+  static const int64_t DEFAULT_FIELD_ENCLOSED_CHAR;
+  static const bool DEFAULT_OPTIONAL_ENCLOSED;
+
+  ObDataInFileStruct()
+      : line_term_str_(DEFAULT_LINE_TERM_STR),
+        line_start_str_(DEFAULT_LINE_BEGIN_STR),
+        field_term_str_(DEFAULT_FIELD_TERM_STR),
+        field_escaped_str_(DEFAULT_FIELD_ESCAPED_STR),
+        field_enclosed_str_(DEFAULT_FIELD_ENCLOSED_STR),
+        field_escaped_char_(DEFAULT_FIELD_ESCAPED_CHAR),
+        field_enclosed_char_(DEFAULT_FIELD_ENCLOSED_CHAR),
+        is_opt_field_enclosed_(DEFAULT_OPTIONAL_ENCLOSED)
+  {}
+  void assign(const ObDataInFileStruct& other)
+  {
+    line_term_str_ = other.line_term_str_;
+    line_start_str_ = other.line_start_str_;
+    field_term_str_ = other.field_term_str_;
+    field_escaped_str_ = other.field_escaped_str_;
+    field_enclosed_str_ = other.field_enclosed_str_;
+    field_escaped_char_ = other.field_escaped_char_;
+    field_enclosed_char_ = other.field_enclosed_char_;
+    is_opt_field_enclosed_ = other.is_opt_field_enclosed_;
+  }
+  TO_STRING_KV(K_(line_term_str), K_(line_start_str), K_(field_term_str), K_(field_escaped_str), K_(field_enclosed_str),
+      K_(field_escaped_char), K_(field_enclosed_char), K_(is_opt_field_enclosed));
+
+  common::ObString line_term_str_;       // line teminated str
+  common::ObString line_start_str_;      // line string by
+  common::ObString field_term_str_;      // field terminated str
+  common::ObString field_escaped_str_;   // field escaped str, such as \, ^, just copy from parsernode data
+  common::ObString field_enclosed_str_;  // field enclosed str, such as ", ', just copy from parsernode data
+  int64_t field_escaped_char_;           // valid escaped char after stmt validation
+  int64_t field_enclosed_char_;          // valid enclosed char after stmt validation
+  bool is_opt_field_enclosed_;           // true means no need use enclosed char for int
+};
+
+class ObLoadDataHint {
+  public:
+  ObLoadDataHint()
+  {
+    reset();
+  }
+  enum IntHintItem {
+    PARALLEL_THREADS = 0,  // parallel threads on the host server, for parsing and calc partition
+    BATCH_SIZE,
+    QUERY_TIMEOUT,
+    TOTAL_INT_ITEM
+  };
+  enum StringHintItem { LOG_LEVEL, TOTAL_STRING_ITEM };
+  void reset()
+  {
+    memset(integer_values_, 0, sizeof(integer_values_));
+    for (int64_t i = 0; i < TOTAL_STRING_ITEM; ++i) {
+      string_values_[i].reset();
+    }
+  }
+  int set_value(IntHintItem item, int64_t value);
+  int get_value(IntHintItem item, int64_t& value) const;
+  int set_value(StringHintItem item, const ObString& value);
+  int get_value(StringHintItem item, ObString& value) const;
+  TO_STRING_KV("Int Hint Item", common::ObArrayWrap<int64_t>(integer_values_, TOTAL_INT_ITEM), "String Hint Item",
+      common::ObArrayWrap<ObString>(string_values_, TOTAL_STRING_ITEM));
+
+  private:
+  int64_t integer_values_[TOTAL_INT_ITEM];
+  ObString string_values_[TOTAL_STRING_ITEM];
+};
+
+class ObLoadDataStmt : public ObCMDStmt {
+  public:
+  struct FieldOrVarStruct {
+    FieldOrVarStruct()
+        : field_or_var_name_(), column_id_(OB_INVALID_ID), column_type_(common::ObMaxType), is_table_column_(true)
+    {}
+    TO_STRING_KV(K_(field_or_var_name), K_(column_id), K_(column_type), K_(is_table_column));
+    ObString field_or_var_name_;
+    uint64_t column_id_;
+    common::ColumnType column_type_;
+    bool is_table_column_;  // false: is a user variable
+  };
+
+  ObLoadDataStmt() : ObCMDStmt(stmt::T_LOAD_DATA), is_default_table_columns_(false)
+  {}
+  virtual ~ObLoadDataStmt()
+  {}
+  // let previous transaction commit first
+  virtual bool cause_implicit_commit() const
+  {
+    return true;
+  }
+
+  int add_assignment(ObAssignment& assign)
+  {
+    return assignments_.push_back(assign);
+  }
+  const ObAssignments& get_table_assignment() const
+  {
+    return assignments_;
+  }
+  ObLoadArgument& get_load_arguments()
+  {
+    return load_args_;
+  }
+  const ObLoadArgument& get_load_arguments() const
+  {
+    return load_args_;
+  }
+  ObDataInFileStruct& get_data_struct_in_file()
+  {
+    return data_struct_in_file_;
+  }
+  const ObDataInFileStruct& get_data_struct_in_file() const
+  {
+    return data_struct_in_file_;
+  }
+  common::ObIArray<FieldOrVarStruct>& get_field_or_var_list()
+  {
+    return field_or_var_list_;
+  }
+  const common::ObIArray<FieldOrVarStruct>& get_field_or_var_list() const
+  {
+    return field_or_var_list_;
+  }
+  int add_column_item(ColumnItem& item);
+  ColumnItem* get_column_item_by_idx(uint64_t column_id);
+  ObLoadDataHint& get_hints()
+  {
+    return hints_;
+  }
+  void set_default_table_columns()
+  {
+    is_default_table_columns_ = true;
+  }
+  bool get_default_table_columns()
+  {
+    return is_default_table_columns_;
+  }
+  TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(load_args), K_(data_struct_in_file), K_(field_or_var_list),
+      K_(assignments), K_(hints), K_(is_default_table_columns));
+
+  private:
+  ObLoadArgument load_args_;
+  ObDataInFileStruct data_struct_in_file_;
+  common::ObSEArray<FieldOrVarStruct, 4> field_or_var_list_;
+  common::ObSEArray<ColumnItem, 16> column_items_;
+  ObAssignments assignments_;
+  ObLoadDataHint hints_;
+  bool is_default_table_columns_;
+
+  DISALLOW_COPY_AND_ASSIGN(ObLoadDataStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif

src/sql/resolver/cmd/ob_resource_resolver.cpp

@@ -0,0 +1,601 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+
+#include "ob_resource_resolver.h"
+
+using namespace oceanbase::common;
+using namespace oceanbase::sql;
+
+ObCreateResourcePoolResolver::ObCreateResourcePoolResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObCreateResourcePoolResolver::~ObCreateResourcePoolResolver()
+{}
+
+ObSplitResourcePoolResolver::ObSplitResourcePoolResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObSplitResourcePoolResolver::~ObSplitResourcePoolResolver()
+{}
+
+ObMergeResourcePoolResolver::ObMergeResourcePoolResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObMergeResourcePoolResolver::~ObMergeResourcePoolResolver()
+{}
+
+ObAlterResourcePoolResolver::ObAlterResourcePoolResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObAlterResourcePoolResolver::~ObAlterResourcePoolResolver()
+{}
+
+ObDropResourcePoolResolver::ObDropResourcePoolResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObDropResourcePoolResolver::~ObDropResourcePoolResolver()
+{}
+
+ObCreateResourceUnitResolver::ObCreateResourceUnitResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObCreateResourceUnitResolver::~ObCreateResourceUnitResolver()
+{}
+
+ObAlterResourceUnitResolver::ObAlterResourceUnitResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObAlterResourceUnitResolver::~ObAlterResourceUnitResolver()
+{}
+
+ObDropResourceUnitResolver::ObDropResourceUnitResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObDropResourceUnitResolver::~ObDropResourceUnitResolver()
+{}
+
+int ObCreateResourcePoolResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObCreateResourcePoolStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || T_CREATE_RESOURCE_POOL != node->type_ || OB_UNLIKELY(3 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid parse node", K(ret));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObCreateResourcePoolStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create select stmt", K(ret));
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[0]) {
+      if (OB_UNLIKELY(T_IF_NOT_EXISTS != node->children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", "type", node->children_[0]->type_);
+      } else {
+        mystmt->set_if_not_exist(true);
+      }
+    } else {
+      mystmt->set_if_not_exist(false);
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    ObString res_pool_name;
+    if (OB_ISNULL(node->children_[1]) || OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", "child", node->children_[1]);
+    } else {
+      res_pool_name.assign_ptr(
+          (char*)(node->children_[1]->str_value_), static_cast<int32_t>(node->children_[1]->str_len_));
+      mystmt->set_resource_pool_name(res_pool_name);
+    }
+  }
+
+  /* options */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[2]) {
+      if (T_RESOURCE_POOL_OPTION_LIST != node->children_[2]->type_) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node type", "child", node->children_[2]->type_);
+      } else {
+        ObResourcePoolOptionResolver<ObCreateResourcePoolStmt> opt_resolver;
+        ret = opt_resolver.resolve_options(mystmt, node->children_[2]);
+      }
+    }
+  }
+
+  return ret;
+}
+
+int ObSplitResourcePoolResolver::resolve_split_pool_list(ObSplitResourcePoolStmt* stmt, const ParseNode& parse_node)
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(NULL == stmt)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", K(ret));
+  } else if (OB_UNLIKELY(T_RESOURCE_POOL_LIST != parse_node.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("unexpected node type", K(ret), "node_type", parse_node.type_);
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < parse_node.num_child_; ++i) {
+      ParseNode* element = parse_node.children_[i];
+      if (OB_UNLIKELY(NULL == element)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else if (OB_UNLIKELY(T_VARCHAR != element->type_)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else {
+        common::ObString pool_str(element->str_len_, element->str_value_);
+        if (OB_FAIL(stmt->add_split_pool(pool_str))) {
+          LOG_WARN("fail to add split pool", K(ret));
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+int ObSplitResourcePoolResolver::resolve_corresponding_zone_list(
+    ObSplitResourcePoolStmt* stmt, const ParseNode& parse_node)
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(NULL == stmt)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", K(ret));
+  } else if (OB_UNLIKELY(T_ZONE_LIST != parse_node.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("unexpected node type", K(ret), "node_type", parse_node.type_);
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < parse_node.num_child_; ++i) {
+      ParseNode* element = parse_node.children_[i];
+      if (OB_UNLIKELY(NULL == element)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else if (OB_UNLIKELY(T_VARCHAR != element->type_)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else {
+        common::ObString zone_str(element->str_len_, element->str_value_);
+        if (OB_FAIL(stmt->add_corresponding_zone(zone_str))) {
+          LOG_WARN("fail to add corresponding zone", K(ret));
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+int ObSplitResourcePoolResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObSplitResourcePoolStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || OB_UNLIKELY(T_SPLIT_RESOURCE_POOL != node->type_) || OB_UNLIKELY(3 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", K(node));
+  } else if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObSplitResourcePoolStmt>()))) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("failed to create split resource pool stmt", K(ret));
+  } else {
+    stmt_ = mystmt;
+  }
+  // resource pool name
+  if (OB_SUCC(ret)) {
+    ObString resource_pool_name;
+    if (OB_UNLIKELY(NULL == node->children_[0])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("node child 0 ptr is null", K(ret));
+    } else if (OB_UNLIKELY(T_IDENT != node->children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("unexpected node", K(ret), "node_type", node->children_[0]->type_);
+    } else {
+      resource_pool_name.assign_ptr(
+          (char*)(node->children_[0]->str_value_), static_cast<int32_t>(node->children_[0]->str_len_));
+      mystmt->set_resource_pool_name(resource_pool_name);
+    }
+  }
+  // split into new resource pools
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[1])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("node child 1 ptr is null", K(ret));
+    } else if (OB_UNLIKELY(T_RESOURCE_POOL_LIST != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("unexpected node", K(ret), "node_type", node->children_[1]->type_);
+    } else if (OB_FAIL(resolve_split_pool_list(mystmt, *node->children_[1]))) {
+      LOG_WARN("fail to resolve split pool list", K(ret));
+    }
+  }
+  // corresponding zones
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[2])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("node child 2 ptr is null", K(ret));
+    } else if (OB_UNLIKELY(T_ZONE_LIST != node->children_[2]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("unexpected node", K(ret), "node_type", node->children_[2]->type_);
+    } else if (OB_FAIL(resolve_corresponding_zone_list(mystmt, *node->children_[2]))) {
+      LOG_WARN("fail to resolve corresponding zone list", K(ret));
+    }
+  }
+  return ret;
+}
+
+int ObMergeResourcePoolResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObMergeResourcePoolStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || OB_UNLIKELY(T_MERGE_RESOURCE_POOL != node->type_) || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", K(node));
+  } else if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObMergeResourcePoolStmt>()))) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("failed to create merge resource pool stmt", K(ret));
+  } else {
+    stmt_ = mystmt;
+  }
+
+  // to be merged resource pool
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[0])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("node child 0 ptr is null", K(ret));
+    } else if (OB_UNLIKELY(T_RESOURCE_POOL_LIST != node->children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("unexpected node", K(ret), "node_type", node->children_[0]->type_);
+    } else if (OB_FAIL(resolve_old_merge_pool_list(mystmt, *node->children_[0]))) {
+      LOG_WARN("fail to resolve old merge pool list", K(ret));
+    }
+  }
+  // merge new resource pool
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[1])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("node child 1 ptr is null", K(ret));
+    } else if (OB_UNLIKELY(T_RESOURCE_POOL_LIST != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("unexpected node", K(ret), "node_type", node->children_[1]->type_);
+    } else if (OB_FAIL(resolve_new_merge_pool_list(mystmt, *node->children_[1]))) {
+      LOG_WARN("fail to resolve new merge pool list", K(ret));
+    }
+  }
+  return ret;
+}
+
+int ObMergeResourcePoolResolver::resolve_old_merge_pool_list(ObMergeResourcePoolStmt* stmt, const ParseNode& parse_node)
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(NULL == stmt)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", K(ret));
+  } else if (OB_UNLIKELY(T_RESOURCE_POOL_LIST != parse_node.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("unexpected node type", K(ret), "node_type", parse_node.type_);
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < parse_node.num_child_; ++i) {
+      ParseNode* element = parse_node.children_[i];
+      if (OB_UNLIKELY(NULL == element)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else if (OB_UNLIKELY(T_VARCHAR != element->type_)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else {
+        common::ObString pool_str(element->str_len_, element->str_value_);
+        if (OB_FAIL(stmt->add_old_pool(pool_str))) {
+          LOG_WARN("fail to add old pool", K(ret));
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+int ObMergeResourcePoolResolver::resolve_new_merge_pool_list(ObMergeResourcePoolStmt* stmt, const ParseNode& parse_node)
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(NULL == stmt)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", K(ret));
+  } else if (OB_UNLIKELY(T_RESOURCE_POOL_LIST != parse_node.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("unexpected node type", K(ret), "node_type", parse_node.type_);
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < parse_node.num_child_; ++i) {
+      ParseNode* element = parse_node.children_[i];
+      if (OB_UNLIKELY(NULL == element)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else if (OB_UNLIKELY(T_VARCHAR != element->type_)) {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        LOG_WARN("unexpected zone node", K(ret));
+      } else {
+        common::ObString pool_str(element->str_len_, element->str_value_);
+        if (OB_FAIL(stmt->add_new_pool(pool_str))) {
+          LOG_WARN("fail to add new pool", K(ret));
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+int ObAlterResourcePoolResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObAlterResourcePoolStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || OB_UNLIKELY(T_ALTER_RESOURCE_POOL != node->type_) || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", K(node));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObAlterResourcePoolStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create select stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* res pool name */
+  if (OB_SUCC(ret)) {
+    ObString res_pool_name;
+    if (OB_UNLIKELY(T_IDENT != node->children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", K(ret));
+    } else {
+      res_pool_name.assign_ptr(
+          (char*)(node->children_[0]->str_value_), static_cast<int32_t>(node->children_[0]->str_len_));
+      mystmt->set_resource_pool_name(res_pool_name);
+    }
+  }
+
+  /* options */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[1]) {
+      if (OB_UNLIKELY(T_RESOURCE_POOL_OPTION_LIST != node->children_[1]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", K(ret));
+      } else {
+        ObResourcePoolOptionResolver<ObAlterResourcePoolStmt> opt_resolver;
+        ret = opt_resolver.resolve_options(mystmt, node->children_[1]);
+      }
+    }
+  }
+
+  return ret;
+}
+
+int ObDropResourcePoolResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObDropResourcePoolStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || OB_UNLIKELY(T_DROP_RESOURCE_POOL != node->type_) || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", K(node));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObDropResourcePoolStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* resource pool name */
+  if (OB_SUCC(ret)) {
+    if (node->children_[0] != NULL) {
+      if (OB_UNLIKELY(T_IF_EXISTS != node->children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", K(ret));
+      } else {
+        mystmt->set_if_exist(true);
+      }
+    } else {
+      mystmt->set_if_exist(false);
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", K(ret));
+    } else {
+      ObString res_pool_name;
+      res_pool_name.assign_ptr(
+          (char*)(node->children_[1]->str_value_), static_cast<int32_t>(node->children_[1]->str_len_));
+      mystmt->set_resource_pool_name(res_pool_name);
+    }
+  }
+
+  return ret;
+}
+
+int ObCreateResourceUnitResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObCreateResourceUnitStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || OB_UNLIKELY(T_CREATE_RESOURCE_UNIT != node->type_) || OB_UNLIKELY(3 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", K(node));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObCreateResourceUnitStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create select stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* res unit name */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[0]) {
+      if (OB_UNLIKELY(T_IF_NOT_EXISTS != node->children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", K(ret));
+      } else {
+        mystmt->set_if_not_exist(true);
+      }
+    } else {
+      mystmt->set_if_not_exist(false);
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node");
+    } else {
+      ObString res_unit_name;
+      res_unit_name.assign_ptr(
+          (char*)(node->children_[1]->str_value_), static_cast<int32_t>(node->children_[1]->str_len_));
+      mystmt->set_resource_unit_name(res_unit_name);
+    }
+  }
+
+  /* options */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[2]) {
+      if (OB_UNLIKELY(T_RESOURCE_UNIT_OPTION_LIST != node->children_[2]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", K(ret));
+      } else {
+        ObResourceUnitOptionResolver<ObCreateResourceUnitStmt> opt_resolver;
+        ret = opt_resolver.resolve_options(mystmt, node->children_[2]);
+      }
+    }
+  }
+
+  return ret;
+}
+
+int ObAlterResourceUnitResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObAlterResourceUnitStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || T_ALTER_RESOURCE_UNIT != node->type_ || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid parse node", K(ret));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObAlterResourceUnitStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create alter resource unit stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* res unit name */
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(T_IDENT != node->children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", K(ret));
+    } else {
+      ObString res_unit_name;
+      res_unit_name.assign_ptr(
+          (char*)(node->children_[0]->str_value_), static_cast<int32_t>(node->children_[0]->str_len_));
+      mystmt->set_resource_unit_name(res_unit_name);
+    }
+  }
+
+  /* options */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[1]) {
+      if (OB_UNLIKELY(T_RESOURCE_UNIT_OPTION_LIST != node->children_[1]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", K(ret));
+      } else {
+        ObResourceUnitOptionResolver<ObAlterResourceUnitStmt> opt_resolver;
+        ret = opt_resolver.resolve_options(mystmt, node->children_[1]);
+      }
+    }
+  }
+
+  return ret;
+}
+
+int ObDropResourceUnitResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode* node = const_cast<ParseNode*>(&parse_tree);
+  ObDropResourceUnitStmt* mystmt = NULL;
+
+  if (OB_ISNULL(node) || T_DROP_RESOURCE_UNIT != node->type_ || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid parse node", K(ret));
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObDropResourceUnitStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (node->children_[0] != NULL) {
+      if (OB_UNLIKELY(T_IF_EXISTS != node->children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", K(ret));
+      } else {
+        mystmt->set_if_exist(true);
+      }
+    } else {
+      mystmt->set_if_exist(false);
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", K(ret));
+    } else {
+      ObString res_unit_name;
+      res_unit_name.assign_ptr(
+          (char*)(node->children_[1]->str_value_), static_cast<int32_t>(node->children_[1]->str_len_));
+      mystmt->set_resource_unit_name(res_unit_name);
+    }
+  }
+
+  return ret;
+}

src/sql/resolver/cmd/ob_resource_resolver.h

@@ -0,0 +1,524 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_RESOURCE_RESOLVER_
+#define OCEANBASE_SQL_RESOLVER_CMD_RESOURCE_RESOLVER_
+
+#include "lib/oblog/ob_log.h"
+#include "lib/string/ob_sql_string.h"
+#include "share/config/ob_config_helper.h"
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+#include "sql/resolver/cmd/ob_resource_stmt.h"
+#include "sql/resolver/cmd/ob_alter_system_resolver.h"
+#include "sql/resolver/ob_stmt.h"
+
+namespace oceanbase {
+namespace sql {
+
+template <class T>
+class ObResourcePoolOptionResolver {
+  public:
+  ObResourcePoolOptionResolver(){};
+  ~ObResourcePoolOptionResolver(){};
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObResourcePoolOptionResolver);
+
+  public:
+  int resolve_options(T* stmt, ParseNode* node) const;
+
+  private:
+  int resolve_option(T* stmt, ParseNode* node) const;
+  int resolve_zone_list(T* stmt, ParseNode* node) const;
+  int resolve_unit_num_option(T* stmt, ParseNode* node) const;
+  int resolve_unit_id_list(T* stmt, ParseNode* node) const;
+};
+
+template <class T>
+int ObResourcePoolOptionResolver<T>::resolve_options(T* stmt, ParseNode* node) const
+{
+  int ret = common::OB_SUCCESS;
+  if (node) {
+    if (OB_UNLIKELY(T_RESOURCE_POOL_OPTION_LIST != node->type_) || OB_UNLIKELY(0 > node->num_child_)) {
+      ret = common::OB_ERR_UNEXPECTED;
+      SQL_RESV_LOG(ERROR, "invalid param", K(ret));
+    } else {
+      ParseNode* option_node = NULL;
+      int32_t num = node->num_child_;
+      for (int32_t i = 0; OB_SUCC(ret) && i < num; i++) {
+        option_node = node->children_[i];
+        if (OB_FAIL(resolve_option(stmt, option_node))) {
+          SQL_RESV_LOG(WARN, "resolve resource option failed", K(ret));
+          break;
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+template <class T>
+int ObResourcePoolOptionResolver<T>::resolve_option(T* stmt, ParseNode* option_node) const
+{
+  int ret = common::OB_SUCCESS;
+  if (OB_ISNULL(stmt)) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(ERROR, "null ptr", K(ret));
+  } else if (option_node) {
+    switch (option_node->type_) {
+      case T_UNIT_NUM: {
+        if (OB_FAIL(resolve_unit_num_option(stmt, option_node))) {
+          SQL_RESV_LOG(WARN, "resolve unit num option failed", K(ret));
+        }
+        break;
+      }
+      case T_ZONE_LIST: {
+        if (OB_FAIL(resolve_zone_list(stmt, option_node))) {
+          SQL_RESV_LOG(WARN, "resolve zone list failed", K(ret));
+        }
+        break;
+      }
+      case T_UNIT: {
+        char* unit_name = const_cast<char*>(option_node->children_[0]->str_value_);
+        common::ObString unit;
+        unit.assign_ptr(unit_name, static_cast<int32_t>(option_node->children_[0]->str_len_));
+        stmt->set_unit(unit);
+        break;
+      }
+      case T_REPLICA_TYPE: {
+        ObReplicaType type;
+        if (option_node->num_child_ != 1 || OB_ISNULL(option_node->children_[0])) {
+          ret = OB_ERR_UNEXPECTED;
+          SQL_RESV_LOG(WARN, "invalid replica type option_node", K(ret), K(option_node));
+        } else if (OB_FAIL(ObAlterSystemResolverUtil::resolve_replica_type(option_node->children_[0], type))) {
+          SQL_RESV_LOG(WARN, "fail to resove repilca type", K(ret));
+        } else {
+          stmt->set_replica_type(type);
+        }
+        break;
+      }
+      default: {
+        /* won't be here */
+        ret = common::OB_ERR_UNEXPECTED;
+        SQL_RESV_LOG(ERROR, "unexprected option", "type", option_node->type_, K(ret));
+        break;
+      }
+    }
+  }
+  return ret;
+}
+
+template <class T>
+int ObResourcePoolOptionResolver<T>::resolve_unit_id_list(T* stmt, ParseNode* node) const
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(NULL == stmt)) {
+    ret = OB_INVALID_ARGUMENT;
+    SQL_RESV_LOG(WARN, "invalid argument", K(ret), K(stmt));
+  } else if (NULL == node) {
+    // may be null node
+  } else if (OB_UNLIKELY(T_UNIT_ID_LIST != node->type_)) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(ERROR, "invalid param", K(ret));
+  } else if (stmt::T_ALTER_RESOURCE_POOL != stmt->get_cmd_type()) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(ERROR, "invalid cmd type", "cmd_type", stmt->get_cmd_type());
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
+      uint64_t unit_id = node->children_[i]->value_;
+      if (OB_FAIL(stmt->fill_delete_unit_id(unit_id))) {
+        SQL_RESV_LOG(WARN, "fail to add unit id", K(ret));
+      }
+    }
+  }
+  return ret;
+}
+
+template <class T>
+int ObResourcePoolOptionResolver<T>::resolve_unit_num_option(T* stmt, ParseNode* node) const
+{
+  using namespace common;
+  int ret = common::OB_SUCCESS;
+  if (OB_UNLIKELY(T_UNIT_NUM != node->type_)) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(ERROR, "invalid param", K(ret));
+  } else if (node->num_child_ < 1 || node->num_child_ > 2) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(ERROR, "invalid node", K(node));
+  } else {
+    int32_t unit_num = static_cast<int32_t>(node->children_[0]->value_);
+    stmt->set_unit_num(unit_num);
+    if (0 == unit_num) {
+      ret = common::OB_INVALID_ARGUMENT;
+      LOG_USER_ERROR(OB_INVALID_ARGUMENT, "unit_num, can't be zero");
+    } else if (1 == node->num_child_) {
+      // do nothing.
+    } else if (stmt::T_ALTER_RESOURCE_POOL != stmt->get_cmd_type()) {
+      if (2 == node->num_child_) {
+        ret = common::OB_NOT_SUPPORTED;
+        LOG_USER_ERROR(OB_NOT_SUPPORTED, "create/drop resource pool with specific unit id");
+      }
+    } else if (OB_FAIL(resolve_unit_id_list(stmt, node->children_[1]))) {
+      SQL_RESV_LOG(WARN, "fail to resolve unit_id_list", K(ret));
+    } else {
+    }  // over, no more to do
+  }
+  return ret;
+}
+
+template <class T>
+int ObResourcePoolOptionResolver<T>::resolve_zone_list(T* stmt, ParseNode* node) const
+{
+  int ret = common::OB_SUCCESS;
+  if (OB_UNLIKELY(T_ZONE_LIST != node->type_)) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(ERROR, "invalid param", K(ret));
+  }
+
+  for (int32_t i = 0; OB_SUCC(ret) && i < node->num_child_; i++) {
+    ParseNode* elem = node->children_[i];
+    if (OB_ISNULL(elem)) {
+      ret = common::OB_ERR_PARSER_SYNTAX;
+      SQL_RESV_LOG(WARN, "Wrong zone");
+    } else {
+      if (OB_LIKELY(T_VARCHAR == elem->type_)) {
+        common::ObString zone_str(elem->str_len_, elem->str_value_);
+        if (OB_FAIL(stmt->add_zone(zone_str))) {
+          SQL_RESV_LOG(WARN, "stmt add_zone failed", K(zone_str), K(ret));
+        }
+      } else {
+        ret = common::OB_ERR_PARSER_SYNTAX;
+        SQL_RESV_LOG(WARN, "Wrong zone");
+        break;
+      }
+    }
+  }
+  return ret;
+}
+
+// use template to reuse for alter unit.
+template <class T>
+class ObResourceUnitOptionResolver {
+  public:
+  ObResourceUnitOptionResolver(){};
+  ~ObResourceUnitOptionResolver(){};
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObResourceUnitOptionResolver);
+
+  public:
+  int resolve_options(T* stmt, ParseNode* node) const;
+
+  private:
+  int resolve_option(T* stmt, ParseNode* node) const;
+};
+
+template <class T>
+int ObResourceUnitOptionResolver<T>::resolve_options(T* stmt, ParseNode* node) const
+{
+  int ret = common::OB_SUCCESS;
+  if (node) {
+    if (OB_UNLIKELY(node->type_ != T_RESOURCE_UNIT_OPTION_LIST) || OB_UNLIKELY(node->num_child_ < 0)) {
+      ret = common::OB_ERR_UNEXPECTED;
+      SQL_RESV_LOG(WARN, "invalid node", K(ret));
+    } else {
+      ParseNode* option_node = NULL;
+      int32_t num = node->num_child_;
+      for (int32_t i = 0; OB_SUCC(ret) && i < num; i++) {
+        option_node = node->children_[i];
+        if (OB_FAIL(resolve_option(stmt, option_node))) {
+          SQL_RESV_LOG(WARN, "resolve resource option failed", K(ret));
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+template <class T>
+int ObResourceUnitOptionResolver<T>::resolve_option(T* stmt, ParseNode* option_node) const
+{
+  using namespace common;
+  int ret = common::OB_SUCCESS;
+  if (OB_ISNULL(stmt)) {
+    ret = common::OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(WARN, "invalid stmt", K(ret));
+  } else if (OB_LIKELY(NULL != option_node)) {
+    if (OB_UNLIKELY(1 != option_node->num_child_ || NULL == option_node->children_[0])) {
+      ret = common::OB_ERR_UNEXPECTED;
+      SQL_RESV_LOG(ERROR, "invalid node", K(ret));
+    } else {
+      ParseNode* child = option_node->children_[0];
+      // resolve conf value (e.g KB, MB)
+      int64_t unit_num = 0;
+      double cpu = 0;
+      if (T_INT == child->type_) {
+        unit_num = static_cast<int64_t>(child->value_);
+        if (OB_UNLIKELY(0 == unit_num)) {
+          ret = common::OB_INVALID_ARGUMENT;
+          LOG_USER_ERROR(OB_INVALID_ARGUMENT, "param, the param can't be zero");
+        }
+      } else if (T_VARCHAR == child->type_) {
+        bool valid = false;
+        common::ObSqlString buf;
+        if (OB_FAIL(buf.append(child->str_value_, child->str_len_))) {
+          SQL_RESV_LOG(WARN, "fail to assign child str", K(ret));
+        } else {
+          // create resource unit unit_test4 max_cpu '1', max_iops '128'
+          // equal to
+          // create resource unit unit_test4 max_cpu 1, max_iops 128
+          // for backward compatibility.
+          //
+          // create resource unit unit_test4 max_memory '1', max_disk_size '128'
+          // equal to
+          // create resource unit unit_test4 max_memory 1048576, max_disk_size 134217728
+          // for backward compatibility, because the unit of string value like '128' is MB
+          // in oberver with old version.
+          if (T_MIN_CPU == option_node->type_ || T_MAX_CPU == option_node->type_ || T_MIN_IOPS == option_node->type_ ||
+              T_MAX_IOPS == option_node->type_ || T_MAX_SESSION_NUM == option_node->type_) {
+            //  '3' = 3, '3k' = 3000, '3m' = 3000000
+            //  not support: 3kb, 3mb, 3gb, 3g, 3t, 3tb etc
+            unit_num = common::ObConfigReadableIntParser::get(buf.ptr(), valid);
+          } else {
+            // '3' = '3mb' = 3*1024*1024
+            unit_num = common::ObConfigCapacityParser::get(buf.ptr(), valid);
+          }
+          if (!valid) {
+            ret = common::OB_ERR_PARSE_SQL;
+          } else if (OB_UNLIKELY(0 == unit_num)) {
+            ret = common::OB_INVALID_ARGUMENT;
+            LOG_USER_ERROR(OB_INVALID_ARGUMENT, "param, the param can't be zero");
+          }
+        }
+      } else if (T_NUMBER == child->type_) {
+        int err = 0;
+        char* endptr = NULL;
+        cpu = common::ObCharset::strntod(child->str_value_, static_cast<int32_t>(child->str_len_), &endptr, &err);
+        if (OB_UNLIKELY(EOVERFLOW == err)) {
+          ret = common::OB_DATA_OUT_OF_RANGE;
+        } else if (OB_UNLIKELY(0 == cpu)) {
+          ret = common::OB_INVALID_ARGUMENT;
+          LOG_USER_ERROR(OB_INVALID_ARGUMENT, "param, the param can't be zero");
+        }
+      } else {
+        ret = common::OB_ERR_PARSE_SQL;
+      }
+
+      if (OB_SUCC(ret)) {
+        switch (option_node->type_) {
+          case T_MIN_MEMORY: {
+            stmt->set_min_memory(unit_num);
+            break;
+          }
+          case T_MIN_IOPS: {
+            stmt->set_min_iops(unit_num);
+            break;
+          }
+          case T_MIN_CPU: {
+            if (T_NUMBER == child->type_) {
+              stmt->set_min_cpu(cpu);
+            } else {
+              stmt->set_min_cpu(static_cast<double>(unit_num));
+            }
+            break;
+          }
+          case T_MAX_MEMORY: {
+            stmt->set_max_memory(unit_num);
+            break;
+          }
+          case T_MAX_DISK_SIZE: {
+            stmt->set_max_disk_size(unit_num);
+            break;
+          }
+          case T_MAX_CPU: {
+            if (T_NUMBER == child->type_) {
+              stmt->set_max_cpu(cpu);
+            } else {
+              stmt->set_max_cpu(static_cast<double>(unit_num));
+            }
+            break;
+          }
+          case T_MAX_IOPS: {
+            stmt->set_max_iops(unit_num);
+            break;
+          }
+          case T_MAX_SESSION_NUM: {
+            stmt->set_max_session_num(unit_num);
+            break;
+          }
+          default: {
+            /* won't be here */
+            ret = common::OB_ERR_UNEXPECTED;
+            break;
+          }
+        }  // switch
+      }    // if
+    }
+  }
+  return ret;
+}
+
+/**************************************************
+ *            Resource Pool Resolver
+ **************************************************/
+class ObCreateResourcePoolResolver : public ObCMDResolver {
+  public:
+  explicit ObCreateResourcePoolResolver(ObResolverParams& params);
+  virtual ~ObCreateResourcePoolResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObCreateResourcePoolResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+class ObSplitResourcePoolResolver : public ObCMDResolver {
+  public:
+  explicit ObSplitResourcePoolResolver(ObResolverParams& params);
+  virtual ~ObSplitResourcePoolResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  int resolve_split_pool_list(ObSplitResourcePoolStmt* stmt, const ParseNode& parse_node);
+  int resolve_corresponding_zone_list(ObSplitResourcePoolStmt* stmt, const ParseNode& parse_node);
+
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObSplitResourcePoolResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+class ObMergeResourcePoolResolver : public ObCMDResolver {
+  public:
+  explicit ObMergeResourcePoolResolver(ObResolverParams& params);
+  virtual ~ObMergeResourcePoolResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  int resolve_old_merge_pool_list(ObMergeResourcePoolStmt* stmt, const ParseNode& parse_node);
+  int resolve_new_merge_pool_list(ObMergeResourcePoolStmt* stmt, const ParseNode& parse_node);
+
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObMergeResourcePoolResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+class ObAlterResourcePoolResolver : public ObCMDResolver {
+  public:
+  explicit ObAlterResourcePoolResolver(ObResolverParams& params);
+  virtual ~ObAlterResourcePoolResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObAlterResourcePoolResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+class ObDropResourcePoolResolver : public ObCMDResolver {
+  public:
+  explicit ObDropResourcePoolResolver(ObResolverParams& params);
+  virtual ~ObDropResourcePoolResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObDropResourcePoolResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+/**************************************************
+ *            Resource Unit Resolver
+ **************************************************/
+class ObCreateResourceUnitResolver : public ObCMDResolver {
+  public:
+  explicit ObCreateResourceUnitResolver(ObResolverParams& params);
+  virtual ~ObCreateResourceUnitResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObCreateResourceUnitResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+class ObAlterResourceUnitResolver : public ObCMDResolver {
+  public:
+  explicit ObAlterResourceUnitResolver(ObResolverParams& params);
+  virtual ~ObAlterResourceUnitResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObAlterResourceUnitResolver);
+  // function members
+};
+
+class ObDropResourceUnitResolver : public ObCMDResolver {
+  public:
+  explicit ObDropResourceUnitResolver(ObResolverParams& params);
+  virtual ~ObDropResourceUnitResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  // types and constants
+  private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObDropResourceUnitResolver);
+  // function members
+
+  private:
+  // data members
+};
+
+}  // end namespace sql
+}  // end namespace oceanbase
+
+#endif /* _OB_CREATE_RESOURCE_RESOLVER_H */

src/sql/resolver/cmd/ob_resource_stmt.h

@@ -0,0 +1,398 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOVER_CMD_RESOURCE_STMT_
+#define OCEANBASE_SQL_RESOVER_CMD_RESOURCE_STMT_
+
+#include "sql/resolver/ddl/ob_ddl_stmt.h"
+#include "share/ob_rpc_struct.h"
+
+namespace oceanbase {
+namespace sql {
+
+class ObCreateResourcePoolStmt : public ObDDLStmt {
+  public:
+  ObCreateResourcePoolStmt(common::ObIAllocator* name_pool)
+      : ObDDLStmt(name_pool, stmt::T_CREATE_RESOURCE_POOL), arg_(){};
+  ObCreateResourcePoolStmt() : ObDDLStmt(stmt::T_CREATE_RESOURCE_POOL), arg_(){};
+  virtual ~ObCreateResourcePoolStmt(){};
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_resource_pool_name(const common::ObString& name)
+  {
+    arg_.pool_name_ = name;
+  }
+  void set_unit(const common::ObString& unit)
+  {
+    arg_.unit_ = unit;
+  }
+  void set_unit_num(const int32_t& unit_num)
+  {
+    arg_.unit_num_ = unit_num;
+  }
+  int add_zone(const common::ObZone& zone)
+  {
+    return arg_.zone_list_.push_back(zone);
+  }
+  void set_if_not_exist(const bool if_not_exist)
+  {
+    arg_.if_not_exist_ = if_not_exist;
+  }
+  obrpc::ObCreateResourcePoolArg& get_arg()
+  {
+    return arg_;
+  }
+  int fill_delete_unit_id(const uint64_t unit_id)
+  {
+    UNUSED(unit_id);
+    return common::OB_NOT_SUPPORTED;
+  }
+  void set_replica_type(const ObReplicaType& type)
+  {
+    arg_.replica_type_ = type;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  obrpc::ObCreateResourcePoolArg arg_;
+  /* functions */
+  /* variables */
+  DISALLOW_COPY_AND_ASSIGN(ObCreateResourcePoolStmt);
+};
+
+class ObSplitResourcePoolStmt : public ObDDLStmt {
+  public:
+  ObSplitResourcePoolStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_SPLIT_RESOURCE_POOL), arg_()
+  {}
+  ObSplitResourcePoolStmt() : ObDDLStmt(stmt::T_SPLIT_RESOURCE_POOL), arg_()
+  {}
+  virtual ~ObSplitResourcePoolStmt()
+  {}
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_resource_pool_name(const common::ObString& name)
+  {
+    arg_.pool_name_ = name;
+  }
+  int add_corresponding_zone(const common::ObZone& zone)
+  {
+    return arg_.zone_list_.push_back(zone);
+  }
+  int add_split_pool(const common::ObString& pool_name)
+  {
+    return arg_.split_pool_list_.push_back(pool_name);
+  }
+  obrpc::ObSplitResourcePoolArg& get_arg()
+  {
+    return arg_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  obrpc::ObSplitResourcePoolArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObSplitResourcePoolStmt);
+};
+
+class ObMergeResourcePoolStmt : public ObDDLStmt {
+  public:
+  ObMergeResourcePoolStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_MERGE_RESOURCE_POOL), arg_()
+  {}
+  ObMergeResourcePoolStmt() : ObDDLStmt(stmt::T_MERGE_RESOURCE_POOL), arg_()
+  {}
+  virtual ~ObMergeResourcePoolStmt()
+  {}
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  int add_old_pool(const common::ObString& pool_name)
+  {
+    return arg_.old_pool_list_.push_back(pool_name);
+  }
+  int add_new_pool(const common::ObString& pool_name)
+  {
+    return arg_.new_pool_list_.push_back(pool_name);
+  }
+  obrpc::ObMergeResourcePoolArg& get_arg()
+  {
+    return arg_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  obrpc::ObMergeResourcePoolArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObMergeResourcePoolStmt);
+};
+
+class ObAlterResourcePoolStmt : public ObDDLStmt {
+  public:
+  ObAlterResourcePoolStmt(common::ObIAllocator* name_pool)
+      : ObDDLStmt(name_pool, stmt::T_ALTER_RESOURCE_POOL), arg_(){};
+  ObAlterResourcePoolStmt() : ObDDLStmt(stmt::T_ALTER_RESOURCE_POOL), arg_(){};
+  virtual ~ObAlterResourcePoolStmt(){};
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_resource_pool_name(const common::ObString& name)
+  {
+    arg_.pool_name_ = name;
+  }
+  void set_unit(const common::ObString& unit)
+  {
+    arg_.unit_ = unit;
+  }
+  void set_unit_num(const int32_t& unit_num)
+  {
+    arg_.unit_num_ = unit_num;
+  }
+  int add_zone(const common::ObZone& zone)
+  {
+    return arg_.zone_list_.push_back(zone);
+  }
+  obrpc::ObAlterResourcePoolArg& get_arg()
+  {
+    return arg_;
+  }
+  int fill_delete_unit_id(const uint64_t unit_id)
+  {
+    return arg_.delete_unit_id_array_.push_back(unit_id);
+  }
+  void set_replica_type(const ObReplicaType& type)
+  {
+    UNUSED(type);
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  /* functions */
+  /* variables */
+  obrpc::ObAlterResourcePoolArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObAlterResourcePoolStmt);
+};
+
+class ObDropResourcePoolStmt : public ObDDLStmt {
+  public:
+  ObDropResourcePoolStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_DROP_RESOURCE_POOL), arg_(){};
+  ObDropResourcePoolStmt() : ObDDLStmt(stmt::T_DROP_RESOURCE_POOL), arg_(){};
+  virtual ~ObDropResourcePoolStmt(){};
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_if_exist(const bool if_exist)
+  {
+    arg_.if_exist_ = if_exist;
+  }
+  void set_resource_pool_name(const common::ObString& name)
+  {
+    arg_.pool_name_ = name;
+  }
+  obrpc::ObDropResourcePoolArg& get_arg()
+  {
+    return arg_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  /* functions */
+  /* variables */
+  obrpc::ObDropResourcePoolArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObDropResourcePoolStmt);
+};
+
+class ObCreateResourceUnitStmt : public ObDDLStmt {
+  public:
+  ObCreateResourceUnitStmt(common::ObIAllocator* name_pool)
+      : ObDDLStmt(name_pool, stmt::T_CREATE_RESOURCE_UNIT), arg_(){};
+  ObCreateResourceUnitStmt() : ObDDLStmt(stmt::T_CREATE_RESOURCE_UNIT), arg_(){};
+  virtual ~ObCreateResourceUnitStmt(){};
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_resource_unit_name(const common::ObString& name)
+  {
+    arg_.unit_name_ = name;
+  }
+  void set_min_cpu(const double min_cpu)
+  {
+    arg_.min_cpu_ = min_cpu;
+  }
+  void set_min_iops(const int64_t min_iops)
+  {
+    arg_.min_iops_ = min_iops;
+  }
+  void set_min_memory(const int64_t min_memory)
+  {
+    arg_.min_memory_ = min_memory;
+  }
+  void set_max_cpu(const double max_cpu)
+  {
+    arg_.max_cpu_ = max_cpu;
+  }
+  void set_max_memory(const int64_t max_memory)
+  {
+    arg_.max_memory_ = max_memory;
+  }
+  void set_max_iops(const int64_t max_iops)
+  {
+    arg_.max_iops_ = max_iops;
+  }
+  void set_max_disk_size(const int64_t max_disk_size)
+  {
+    arg_.max_disk_size_ = max_disk_size;
+  }
+  void set_max_session_num(const int64_t max_session_num)
+  {
+    arg_.max_session_num_ = max_session_num;
+  }
+  void set_if_not_exist(const bool if_not_exist)
+  {
+    arg_.if_not_exist_ = if_not_exist;
+  }
+  obrpc::ObCreateResourceUnitArg& get_arg()
+  {
+    return arg_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  /* functions */
+  /* variables */
+  obrpc::ObCreateResourceUnitArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObCreateResourceUnitStmt);
+};
+
+class ObAlterResourceUnitStmt : public ObDDLStmt {
+  public:
+  ObAlterResourceUnitStmt(common::ObIAllocator* name_pool)
+      : ObDDLStmt(name_pool, stmt::T_ALTER_RESOURCE_UNIT), arg_(){};
+  ObAlterResourceUnitStmt() : ObDDLStmt(stmt::T_ALTER_RESOURCE_UNIT), arg_(){};
+  virtual ~ObAlterResourceUnitStmt(){};
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_resource_unit_name(const common::ObString& name)
+  {
+    arg_.unit_name_ = name;
+  }
+  void set_min_cpu(const double min_cpu)
+  {
+    arg_.min_cpu_ = min_cpu;
+  }
+  void set_min_iops(const int64_t min_iops)
+  {
+    arg_.min_iops_ = min_iops;
+  }
+  void set_min_memory(const int64_t min_memory)
+  {
+    arg_.min_memory_ = min_memory;
+  }
+  void set_max_cpu(const double max_cpu)
+  {
+    arg_.max_cpu_ = max_cpu;
+  }
+  void set_max_memory(const int64_t max_memory)
+  {
+    arg_.max_memory_ = max_memory;
+  }
+  void set_max_iops(const int64_t max_iops)
+  {
+    arg_.max_iops_ = max_iops;
+  }
+  void set_max_disk_size(const int64_t max_disk_size)
+  {
+    arg_.max_disk_size_ = max_disk_size;
+  }
+  void set_max_session_num(const int64_t max_session_num)
+  {
+    arg_.max_session_num_ = max_session_num;
+  }
+  obrpc::ObAlterResourceUnitArg& get_arg()
+  {
+    return arg_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  /* functions */
+  /* variables */
+  obrpc::ObAlterResourceUnitArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObAlterResourceUnitStmt);
+};
+
+class ObDropResourceUnitStmt : public ObDDLStmt {
+  public:
+  ObDropResourceUnitStmt(common::ObIAllocator* name_pool) : ObDDLStmt(name_pool, stmt::T_DROP_RESOURCE_UNIT), arg_()
+  {}
+  ObDropResourceUnitStmt() : ObDDLStmt(stmt::T_DROP_RESOURCE_UNIT), arg_()
+  {}
+  virtual ~ObDropResourceUnitStmt(){};
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  void set_if_exist(const bool if_exist)
+  {
+    arg_.if_exist_ = if_exist;
+  }
+  void set_resource_unit_name(const common::ObString& name)
+  {
+    arg_.unit_name_ = name;
+  }
+  obrpc::ObDropResourceUnitArg& get_arg()
+  {
+    return arg_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return arg_;
+  }
+
+  private:
+  /* functions */
+  /* variables */
+  obrpc::ObDropResourceUnitArg arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObDropResourceUnitStmt);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif  // OCEANBASE_SQL_RESOVER_CMD_RESOURCE_STMT_
+//// end of header file

src/sql/resolver/cmd/ob_set_names_resolver.cpp

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "sql/resolver/cmd/ob_set_names_resolver.h"
+#include "sql/resolver/cmd/ob_set_names_stmt.h"
+
+namespace oceanbase {
+using namespace oceanbase::common;
+namespace sql {
+ObSetNamesResolver::ObSetNamesResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObSetNamesResolver::~ObSetNamesResolver()
+{}
+
+int ObSetNamesResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  if (T_SET_NAMES != parse_tree.type_ && T_SET_CHARSET != parse_tree.type_) {
+    ret = OB_INVALID_ARGUMENT;
+    SQL_RESV_LOG(WARN, "create stmt failed", K(ret));
+  } else if (OB_ISNULL(parse_tree.children_)) {
+    ret = OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(WARN, "parse_tree.children_ is null.", K(ret));
+  } else if (OB_ISNULL(parse_tree.children_[0])) {
+    ret = OB_ERR_UNEXPECTED;
+    SQL_RESV_LOG(WARN, "parse_tree.children_[0] is null.", K(ret));
+  } else {
+    ObSetNamesStmt* stmt = NULL;
+    if (OB_ISNULL(stmt = create_stmt<ObSetNamesStmt>())) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      SQL_RESV_LOG(ERROR, "create stmt failed", K(ret));
+    } else {
+      if (T_SET_NAMES == parse_tree.type_) {
+        // SET NAMES
+        stmt->set_is_set_names(true);
+        if (T_DEFAULT == parse_tree.children_[0]->type_) {
+          stmt->set_is_default_charset(true);
+        } else {
+          ObString charset;
+          charset.assign_ptr(
+              parse_tree.children_[0]->str_value_, static_cast<int32_t>(parse_tree.children_[0]->str_len_));
+          if (0 == charset.case_compare("utf16")) {
+            ret = OB_ERR_WRONG_VALUE_FOR_VAR;
+            LOG_USER_ERROR(OB_ERR_WRONG_VALUE_FOR_VAR,
+                static_cast<int>(strlen("character_set_client")),
+                "character_set_client",
+                charset.length(),
+                charset.ptr());
+          } else {
+            stmt->set_charset(charset);
+          }
+        }
+        if (OB_SUCC(ret)) {
+          if (NULL == parse_tree.children_[1]) {
+            // do nothing
+          } else if (T_DEFAULT == parse_tree.children_[1]->type_) {
+            stmt->set_is_default_collation(true);
+          } else {
+            ObString collation;
+            collation.assign_ptr(
+                parse_tree.children_[1]->str_value_, static_cast<int32_t>(parse_tree.children_[1]->str_len_));
+            stmt->set_collation(collation);
+          }
+        }
+      } else {
+        // SET CHARACTER SET
+        stmt->set_is_set_names(false);
+        if (T_DEFAULT == parse_tree.children_[0]->type_) {
+          stmt->set_is_default_charset(true);
+        } else {
+          ObString charset;
+          charset.assign_ptr(
+              parse_tree.children_[0]->str_value_, static_cast<int32_t>(parse_tree.children_[0]->str_len_));
+          stmt->set_charset(charset);
+        }
+      }
+    }
+  }
+  return ret;
+}
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_set_names_resolver.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef _OB_SET_NAMES_RESOLVER_H
+#define _OB_SET_NAMES_RESOLVER_H
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+// resolver for both SET NAMES and SET CHARSET
+class ObSetNamesResolver : public ObCMDResolver {
+  public:
+  explicit ObSetNamesResolver(ObResolverParams& params);
+  virtual ~ObSetNamesResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObSetNamesResolver);
+};
+
+}  // end namespace sql
+}  // end namespace oceanbase
+
+#endif  // _OB_SET_NAMES_RESOLVER_H

src/sql/resolver/cmd/ob_set_names_stmt.h

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef _OB_SET_NAMES_STMT_H
+#define _OB_SET_NAMES_STMT_H
+#include "lib/string/ob_string.h"
+#include "sql/resolver/cmd/ob_cmd_stmt.h"
+namespace oceanbase {
+namespace sql {
+// statement for both SET NAMES and SET CHARSET
+class ObSetNamesStmt : public ObCMDStmt {
+  public:
+  ObSetNamesStmt()
+      : ObCMDStmt(stmt::T_SET_NAMES), is_set_names_(true), is_default_charset_(false), is_default_collation_(false)
+  {}
+  virtual ~ObSetNamesStmt()
+  {}
+
+  bool is_set_names() const
+  {
+    return this->is_set_names_;
+  }
+  void set_is_set_names(bool is_set_names)
+  {
+    this->is_set_names_ = is_set_names;
+  }
+
+  bool is_default_charset() const
+  {
+    return is_default_charset_;
+  }
+  void set_is_default_charset(bool is_default)
+  {
+    is_default_charset_ = is_default;
+  }
+
+  bool is_default_collation() const
+  {
+    return is_default_collation_;
+  }
+  void set_is_default_collation(bool is_default)
+  {
+    is_default_collation_ = is_default;
+  }
+
+  const common::ObString& get_charset() const
+  {
+    return this->charset_;
+  }
+  void set_charset(const common::ObString& charset)
+  {
+    this->charset_ = charset;
+  }
+
+  const common::ObString& get_collation() const
+  {
+    return this->collation_;
+  }
+  void set_collation(const common::ObString& collation)
+  {
+    this->collation_ = collation;
+  }
+  TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(is_set_names), K_(is_default_charset), K_(is_default_collation),
+      K_(charset), K_(collation));
+
+  private:
+  // types and constants
+  private:
+  // function members
+  private:
+  // data members
+  bool is_set_names_;  // SET NAMES or SET CHARSET?
+  bool is_default_charset_;
+  bool is_default_collation_;
+  common::ObString charset_;
+  common::ObString collation_;
+
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(ObSetNamesStmt);
+};
+
+}  // end namespace sql
+}  // end namespace oceanbase
+
+#endif  // _OB_SET_NAMES_STMT_H

src/sql/resolver/cmd/ob_set_transaction_resolver.cpp

@@ -0,0 +1,240 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+
+#include "sql/resolver/cmd/ob_set_transaction_resolver.h"
+#include "sql/resolver/cmd/ob_variable_set_stmt.h"
+#include "sql/resolver/expr/ob_raw_expr_util.h"
+#include "sql/session/ob_sql_session_info.h"
+#include "sql/ob_trans_character.h"
+using namespace oceanbase::common;
+using namespace oceanbase::transaction;
+namespace oceanbase {
+using namespace share;
+namespace sql {
+ObSetTransactionResolver::ObSetTransactionResolver(ObResolverParams& params) : ObCMDResolver(params)
+{}
+
+ObSetTransactionResolver::~ObSetTransactionResolver()
+{}
+
+int ObSetTransactionResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObVariableSetStmt* stmt = NULL;
+  if (OB_ISNULL(stmt = create_stmt<ObVariableSetStmt>())) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("create stmt failed");
+  } else if (T_TRANSACTION != parse_tree.type_ || OB_ISNULL(parse_tree.children_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid parse node", K(parse_tree.type_), K(parse_tree.children_));
+  } else {
+    ParseNode* characteristics_node = parse_tree.children_[1];
+    ParseNode* scope_node = parse_tree.children_[0];
+    ObVariableSetStmt::VariableSetNode access_var_node;
+    ObVariableSetStmt::VariableSetNode isolation_var_node;
+    ObSetVar::SetScopeType scope = ObSetVar::SET_SCOPE_NEXT_TRANS;
+    int32_t isolation_level = ObTransIsolation::UNKNOWN;
+    bool is_read_only = false;
+    if (OB_ISNULL(scope_node) || OB_ISNULL(characteristics_node)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("inalid scope node", K(scope_node), K(characteristics_node));
+    } else if (OB_FAIL(scope_resolve(*scope_node, scope))) {
+      LOG_WARN("fail to scope resolve", K(ret));
+    } else if (OB_ISNULL(allocator_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid allocator in resolver", K(allocator_));
+    } else {
+      access_var_node.set_scope_ = scope;
+      access_var_node.is_system_variable_ = true;
+      isolation_var_node.set_scope_ = scope;
+      isolation_var_node.is_system_variable_ = true;
+      if (OB_FAIL(ob_write_string(*allocator_, OB_SV_TX_ISOLATION, isolation_var_node.variable_name_))) {
+        LOG_WARN("fail to write string", K(ret));
+      } else if (OB_FAIL(ob_write_string(*allocator_, OB_SV_TX_READ_ONLY, access_var_node.variable_name_))) {
+        LOG_WARN("fail to write string", K(ret));
+      } else {
+        ObCharset::casedn(CS_TYPE_UTF8MB4_GENERAL_CI, isolation_var_node.variable_name_);
+        ObCharset::casedn(CS_TYPE_UTF8MB4_GENERAL_CI, access_var_node.variable_name_);
+      }
+    }
+    bool set_access_mode = false;
+    bool set_isolation_level = false;
+    if (OB_SUCC(ret)) {
+      if (OB_ISNULL(characteristics_node->children_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_WARN("invalid characteristics node", K(characteristics_node->children_));
+      } else {
+        if (NULL != characteristics_node->children_[0]) {
+          if (OB_FAIL(access_mode_resolve(*characteristics_node->children_[0], is_read_only))) {
+            LOG_WARN("fail to resolve access mode", K(ret));
+          } else {
+            set_access_mode = true;
+          }
+        }
+        if (NULL != characteristics_node->children_[1]) {
+          if (OB_FAIL(isolation_level_resolve(*characteristics_node->children_[1], isolation_level))) {
+            LOG_WARN("fail to resolve isolation level", K(ret));
+          } else {
+            set_isolation_level = true;
+          }
+        }
+      }
+    }
+    if (OB_SUCC(ret) && set_isolation_level) {
+      if (OB_FAIL(build_isolation_expr(isolation_var_node.value_expr_, isolation_level))) {
+        LOG_WARN("fail to build isolation expr", K(ret));
+      } else if (OB_FAIL(stmt->add_variable_node(isolation_var_node))) {
+        LOG_WARN("fail to add variable node", K(ret));
+      }
+    }
+    if (OB_SUCC(ret) && set_access_mode) {
+      if (OB_FAIL(build_access_expr(access_var_node.value_expr_, is_read_only))) {
+        LOG_WARN("fail to build access expr", K(ret));
+      } else if (OB_FAIL(stmt->add_variable_node(access_var_node))) {
+        LOG_WARN("fail to add variable node", K(ret));
+      } else {
+        LOG_DEBUG("add variable node", K(is_read_only));
+      }
+    }
+    if (OB_SUCC(ret)) {
+      if (OB_ISNULL(session_info_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid session info", K(ret), K(session_info_));
+      } else {
+        stmt->set_actual_tenant_id(session_info_->get_effective_tenant_id());
+      }
+    }
+  }
+  return ret;
+}
+
+int ObSetTransactionResolver::build_isolation_expr(ObRawExpr*& expr, int32_t level)
+{
+  int ret = OB_SUCCESS;
+  ObObjParam val;
+  ObConstRawExpr* c_expr = NULL;
+  const ObString& level_name = ObTransIsolation::get_name(level);
+  if (OB_ISNULL(params_.expr_factory_)) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("invalid stmt", K_(stmt));
+  } else if (level_name.empty()) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("isolation level is not invalid", K(ret), K(level));
+  } else if (params_.expr_factory_->create_raw_expr(T_VARCHAR, c_expr)) {
+    LOG_WARN("fail to create raw expr");
+  } else {
+    // we use int type to represent isolation level, except for system variable tx_isolation,
+    // which use varchar type, so we need cast int to varchar here.
+    val.set_varchar(level_name);
+    val.set_collation_type(ObCharset::get_system_collation());
+    val.set_param_meta();
+    c_expr->set_param(val);
+    c_expr->set_value(val);
+    c_expr->set_data_type(ObVarcharType);
+    expr = c_expr;
+  }
+  return ret;
+}
+
+int ObSetTransactionResolver::build_access_expr(ObRawExpr*& expr, const bool is_read_only)
+{
+  int ret = OB_SUCCESS;
+  ObObjParam val;
+  ObConstRawExpr* c_expr = NULL;
+  if (is_read_only) {
+    val.set_int(1);
+  } else {
+    val.set_int(0);
+  }
+  val.set_scale(0);
+  val.set_param_meta();
+  if (OB_ISNULL(params_.expr_factory_)) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("invalid stmt", K_(stmt));
+  } else if (OB_FAIL(params_.expr_factory_->create_raw_expr(T_INT, c_expr))) {
+    LOG_WARN("create raw expr failed", K(ret));
+  } else {
+    c_expr->set_param(val);
+    c_expr->set_value(val);
+    c_expr->set_data_type(ObIntType);
+    expr = c_expr;
+  }
+  return ret;
+}
+
+int ObSetTransactionResolver::scope_resolve(const ParseNode& parse_tree, ObSetVar::SetScopeType& scope)
+{
+  int ret = OB_SUCCESS;
+  switch (parse_tree.value_) {
+    case 0:
+      scope = ObSetVar::SET_SCOPE_NEXT_TRANS;
+      break;
+    case 1:
+      scope = ObSetVar::SET_SCOPE_GLOBAL;
+      break;
+    case 2:
+      scope = ObSetVar::SET_SCOPE_SESSION;
+      break;
+    default:
+      scope = ObSetVar::SET_SCOPE_NEXT_TRANS;
+      break;
+  }
+  return ret;
+}
+
+int ObSetTransactionResolver::access_mode_resolve(const ParseNode& parse_tree, bool& is_read_only)
+{
+  int ret = OB_SUCCESS;
+  if (IS_READ_ONLY(parse_tree.value_)) {
+    is_read_only = true;
+  } else if (IS_READ_WRITE(parse_tree.value_)) {
+    is_read_only = false;
+  } else {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("invalid access mode", "value", parse_tree.value_);
+  }
+  return ret;
+}
+
+int ObSetTransactionResolver::isolation_level_resolve(const ParseNode& parse_tree, int32_t& isolation_level)
+{
+  int ret = OB_SUCCESS;
+  switch (parse_tree.value_) {
+    case 0:
+      isolation_level = transaction::ObTransIsolation::READ_UNCOMMITTED;
+      break;
+    case 1:
+      isolation_level = transaction::ObTransIsolation::READ_COMMITED;
+      break;
+    case 2:
+      isolation_level = transaction::ObTransIsolation::REPEATABLE_READ;
+      break;
+    case 3:
+      isolation_level = transaction::ObTransIsolation::SERIALIZABLE;
+      break;
+    default:
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("invalid isolation level", K(parse_tree.value_));
+      break;
+  }
+  if (OB_SUCC(ret)) {
+    if (!transaction::ObTransIsolation::is_valid(isolation_level)) {
+      ret = OB_NOT_SUPPORTED;
+      LOG_WARN("invalid isolation level, we just supported READ_COMMIT and SERIALIZABLE", K(ret));
+    }
+  }
+  return ret;
+}
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_set_transaction_resolver.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_OB_SET_TRANSACTION_RESOLVER_H_
+#define OCEANBASE_SQL_OB_SET_TRANSACTION_RESOLVER_H_
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+class ObSetTransactionResolver : public ObCMDResolver {
+  public:
+  explicit ObSetTransactionResolver(ObResolverParams& params);
+  virtual ~ObSetTransactionResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  int build_isolation_expr(ObRawExpr*& expr, int32_t level);
+  int build_access_expr(ObRawExpr*& expr, const bool is_read_only);
+  int scope_resolve(const ParseNode& parse_tree, share::ObSetVar::SetScopeType& scope);
+  int access_mode_resolve(const ParseNode& parse_tree, bool& is_read_only);
+  int transaction_characteristics_resolve(const ParseNode& parse_tree, bool& is_read_only, int32_t& level);
+  int isolation_level_resolve(const ParseNode& parse_tree, int32_t& level);
+  DISALLOW_COPY_AND_ASSIGN(ObSetTransactionResolver);
+};
+
+}  // end namespace sql
+}  // end namespace oceanbase
+
+#endif /* OCEANBASE_SQL_OB_SET_TRANSACTION_RESOLVER_H_*/

src/sql/resolver/cmd/ob_show_resolver.h

@@ -0,0 +1,191 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_SHOW_RESOLVER_
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_SHOW_RESOLVER_
+#include "sql/resolver/dml/ob_select_resolver.h"
+namespace oceanbase {
+namespace sql {
+class ObShowResolver : public ObSelectResolver {
+  public:
+  class ObShowResolverContext;
+  class ShowColumnInfo;
+  explicit ObShowResolver(ObResolverParams& params);
+  virtual ~ObShowResolver();
+  virtual int resolve(const ParseNode& parse_tree);
+
+  protected:
+  private:
+  class ObSqlStrGenerator;
+  struct ObShowSqlSet;
+  int get_database_info(const ParseNode* databse_node, const common::ObString& database_name, uint64_t real_tenant_id,
+      ObShowResolverContext& show_resv_ctx, uint64_t& show_db_id);
+
+  int resolve_show_from_table(const ParseNode* from_table_node, const ParseNode* from_database_clause_node,
+      bool is_database_unselected, ObItemType node_type, uint64_t real_tenant_id, common::ObString& show_database_name,
+      uint64_t& show_database_id, common::ObString& show_table_name, uint64_t& show_table_id, bool& is_view,
+      ObSynonymChecker& synonym_checker);
+  int resolve_show_from_database(const ParseNode& from_db_node, uint64_t real_tenant_id, uint64_t& show_database_id,
+      common::ObString& show_database_name);
+  int parse_and_resolve_select_sql(const common::ObString& select_sql);
+  int resolve_like_or_where_clause(ObShowResolverContext& ctx);
+  int replace_where_clause(ParseNode* expr_node, const ObShowResolverContext& show_resv_ctx);
+  int process_select_type(ObSelectStmt* select_stmt, stmt::StmtType stmt_type, const ParseNode& parse_tree);
+  virtual int resolve_column_ref_expr(const ObQualifiedName& q_name, ObRawExpr*& real_ref_expr);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObShowResolver);
+};  // ObShowresolver
+
+struct ObShowResolver::ObShowSqlSet {
+#define DECLARE_SHOW_CLAUSE_SET(SHOW_STMT_TYPE)     \
+  static const char* SHOW_STMT_TYPE##_SELECT;       \
+  static const char* SHOW_STMT_TYPE##_SUBQUERY;     \
+  static const char* SHOW_STMT_TYPE##_ORA_SUBQUERY; \
+  static const char* SHOW_STMT_TYPE##_LIKE
+
+  static const char* SUBQERY_ALIAS;
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TABLES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TABLES_LIKE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_FULL_TABLES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_FULL_TABLES_LIKE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CHARSET);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TABLEGROUPS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_VARIABLES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_GLOBAL_VARIABLES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_COLUMNS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_FULL_COLUMNS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_DATABASE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_DATABASE_EXISTS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_TABLEGROUP);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_TABLEGROUP_EXISTS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_INDEXES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_COLLATION);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TRACE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_ENGINES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PRIVILEGES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_GRANTS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PROCESSLIST);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_FULL_PROCESSLIST);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_SYS_PROCESSLIST);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_SYS_FULL_PROCESSLIST);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TABLE_STATUS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PROCEDURE_STATUS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_WARNINGS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_COUNT_WARNINGS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_ERRORS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_COUNT_ERRORS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PARAMETERS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PARAMETERS_UNSYS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PARAMETERS_COMPAT);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_PARAMETERS_SEED);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_SESSION_STATUS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_GLOBAL_STATUS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TENANT);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TENANT_STATUS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_TENANT);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_DATABASES);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_DATABASES_LIKE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_DATABASES_STATUS);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_DATABASES_STATUS_LIKE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_TABLE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_VIEW);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_PROCEDURE);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_CREATE_FUNCTION);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_RECYCLEBIN);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_SYS_RECYCLEBIN);
+  DECLARE_SHOW_CLAUSE_SET(SHOW_TRIGGERS);
+};  // ObShowSqlSet
+
+class ObShowResolver::ObSqlStrGenerator {
+  public:
+  ObSqlStrGenerator() : sql_buf_(NULL), sql_buf_pos_(0)
+  {}
+  virtual ~ObSqlStrGenerator()
+  {}
+  int init(common::ObIAllocator* alloc);
+  virtual int gen_select_str(const char* select_str, ...);
+  virtual int gen_from_str(const char* subquery_str, ...);
+  virtual int gen_limit_str(int64_t offset, int64_t row_cnt);
+  void assign_sql_str(common::ObString& sql_str);
+
+  private:
+  char* sql_buf_;
+  int64_t sql_buf_pos_;
+  DISALLOW_COPY_AND_ASSIGN(ObSqlStrGenerator);
+};  // ObSqlstrgenerator
+
+class ObShowResolver::ObShowResolverContext {
+  public:
+  ObShowResolverContext()
+      : cur_tenant_id_(common::OB_INVALID_ID),
+        actual_tenant_id_(common::OB_INVALID_ID),
+        database_name_(),
+        ref_table_id_(common::OB_INVALID_ID),
+        show_database_name_(),
+        show_database_id_(common::OB_INVALID_ID),
+        show_table_id_(common::OB_INVALID_ID),
+        grants_user_name_(),
+        grants_user_id_(common::OB_INVALID_ID),
+        stmt_type_(stmt::T_NONE),
+        global_scope_(false),
+        like_pattern_(),
+        like_escape_(),
+        parse_tree_(NULL),
+        condition_node_(NULL),
+        column_name_(),
+        like_column_()
+  {}
+  ~ObShowResolverContext()
+  {}
+  uint64_t cur_tenant_id_;
+  uint64_t actual_tenant_id_;
+  common::ObString database_name_;
+  uint64_t ref_table_id_;
+  common::ObString show_database_name_;
+  uint64_t show_database_id_;
+  uint64_t show_table_id_;
+  common::ObString grants_user_name_;
+  uint64_t grants_user_id_;
+  stmt::StmtType stmt_type_;
+  bool global_scope_;
+  common::ObString like_pattern_;
+  common::ObString like_escape_;
+  const ParseNode* parse_tree_;
+  ParseNode* condition_node_;
+  common::ObString column_name_;  // used for show tables
+  common::ObString like_column_;  // used for the show stmt who has like clause
+  TO_STRING_KV(K_(cur_tenant_id), K_(actual_tenant_id), K_(database_name), K_(ref_table_id), K_(show_database_name),
+      K_(show_database_id), K_(show_table_id), K_(stmt_type), K_(global_scope), K_(like_pattern), K_(like_escape),
+      K_(column_name));
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObShowResolverContext);
+};  // ObShowResolvercontext
+
+class ObShowResolver::ShowColumnInfo {
+  public:
+  ShowColumnInfo() : display_name_(), qualified_name_()
+  {}
+  ~ShowColumnInfo()
+  {}
+  common::ObString display_name_;
+  ObQualifiedName qualified_name_;
+  TO_STRING_KV(K_(display_name), K_(qualified_name));
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ShowColumnInfo);
+};  // ShowColumninfo
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_OB_SHOW_RESOLVER_ */

src/sql/resolver/cmd/ob_system_cmd_resolver.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_SYSTEM_CMD_RESOLVER_
+#define OCEANBASE_SQL_RESOLVER_CMD_SYSTEM_CMD_RESOLVER_
+
+#include "sql/resolver/ob_stmt_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+class ObSystemCmdResolver : public ObStmtResolver {
+  public:
+  explicit ObSystemCmdResolver(ObResolverParams& params) : ObStmtResolver(params)
+  {}
+  virtual ~ObSystemCmdResolver()
+  {}
+
+  private:
+  /* functions */
+  /* variables */
+  DISALLOW_COPY_AND_ASSIGN(ObSystemCmdResolver);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_SYSTEM_CMD_RESOLVER_ */

src/sql/resolver/cmd/ob_system_cmd_stmt.h

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_SYSTEM_CMD_STMT_
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_SYSTEM_CMD_STMT_
+
+#include "sql/resolver/ob_stmt.h"
+#include "sql/resolver/ob_cmd.h"
+namespace oceanbase {
+namespace sql {
+class ObSystemCmdStmt : public ObStmt, public ObICmd {
+  public:
+  ObSystemCmdStmt(common::ObIAllocator* name_pool, stmt::StmtType type) : ObStmt(name_pool, type)
+  {}
+  explicit ObSystemCmdStmt(stmt::StmtType type) : ObStmt(type)
+  {}
+  virtual ~ObSystemCmdStmt()
+  {}
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObSystemCmdStmt);
+};
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_OB_SYSTEM_CMD_STMT_ */

src/sql/resolver/cmd/ob_variable_set_resolver.cpp

@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+#include "sql/resolver/ob_resolver_utils.h"
+#include "sql/resolver/expr/ob_raw_expr_util.h"
+#include "sql/resolver/dml/ob_select_resolver.h"
+#include "sql/resolver/cmd/ob_variable_set_resolver.h"
+#include "sql/resolver/cmd/ob_variable_set_stmt.h"
+#include "sql/session/ob_sql_session_info.h"
+namespace oceanbase {
+using namespace common;
+using namespace share;
+namespace sql {
+
+ObVariableSetResolver::ObVariableSetResolver(ObResolverParams& params) : ObStmtResolver(params)
+{}
+
+ObVariableSetResolver::~ObVariableSetResolver()
+{}
+
+int ObVariableSetResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObVariableSetStmt* variable_set_stmt = NULL;
+  if (OB_UNLIKELY(T_VARIABLE_SET != parse_tree.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("parse_tree.type_ must be T_VARIABLE_SET", K(ret), K(parse_tree.type_));
+  } else if (OB_ISNULL(session_info_) || OB_ISNULL(allocator_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("session_info_ or allocator_ is NULL", K(ret), K(session_info_), K(allocator_));
+  } else if (OB_ISNULL(variable_set_stmt = create_stmt<ObVariableSetStmt>())) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("create variable set stmt failed", K(ret));
+  } else {
+    stmt_ = variable_set_stmt;
+    variable_set_stmt->set_actual_tenant_id(session_info_->get_effective_tenant_id());
+    ParseNode* set_node = NULL;
+    ObVariableSetStmt::VariableSetNode var_node;
+    for (int64_t i = 0; OB_SUCC(ret) && i < parse_tree.num_child_; ++i) {
+      if (OB_ISNULL(set_node = parse_tree.children_[i])) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("set node is NULL", K(ret));
+      } else if (OB_UNLIKELY(T_VAR_VAL != set_node->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("set_node->type_ must be T_VAR_VAL", K(ret), K(set_node->type_));
+      } else {
+        ParseNode* var = NULL;
+        switch (set_node->value_) {
+          case 0:
+            var_node.set_scope_ = ObSetVar::SET_SCOPE_SESSION;
+            break;
+          case 1:
+            var_node.set_scope_ = ObSetVar::SET_SCOPE_GLOBAL;
+            variable_set_stmt->set_has_global_variable(true);
+            break;
+          case 2:
+            var_node.set_scope_ = ObSetVar::SET_SCOPE_SESSION;
+            break;
+          default:
+            var_node.set_scope_ = ObSetVar::SET_SCOPE_NEXT_TRANS;
+            break;
+        }
+        if (OB_FAIL(ret)) {
+        } else if (OB_ISNULL(var = set_node->children_[0])) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_ERROR("var is NULL", K(ret));
+        } else {
+          ObString var_name;
+          if (T_IDENT == var->type_) {
+            var_node.is_system_variable_ = true;
+            var_name.assign_ptr(var->str_value_, static_cast<int32_t>(var->str_len_));
+          } else if (T_OBJ_ACCESS_REF == var->type_) {  // Oracle mode
+            const ParseNode* name_node = NULL;
+            if (OB_ISNULL(name_node = var->children_[0]) || OB_UNLIKELY(var->children_[1] != NULL)) {
+              ret = OB_NOT_SUPPORTED;
+              LOG_USER_ERROR(OB_NOT_SUPPORTED, "Variable name not an identifier type");
+            } else if (OB_UNLIKELY(name_node->type_ != T_IDENT)) {
+              ret = OB_NOT_SUPPORTED;
+              LOG_USER_ERROR(OB_NOT_SUPPORTED, "Variable name not an identifier type");
+            } else {
+              var_node.is_system_variable_ = true;
+              var_name.assign_ptr(name_node->str_value_, static_cast<int32_t>(name_node->str_len_));
+            }
+          } else {
+            var_node.is_system_variable_ = (T_SYSTEM_VARIABLE == var->type_);
+            var_name.assign_ptr(var->str_value_, static_cast<int32_t>(var->str_len_));
+          }
+          if (OB_SUCC(ret)) {
+            if (OB_FAIL(ob_write_string(*allocator_, var_name, var_node.variable_name_))) {
+              LOG_WARN("Can not malloc space for variable name", K(ret));
+            } else {
+              ObCharset::casedn(CS_TYPE_UTF8MB4_GENERAL_CI, var_node.variable_name_);
+            }
+          }
+          if (OB_FAIL(ret)) {
+          } else if (OB_ISNULL(set_node->children_[1])) {
+            ret = OB_INVALID_ARGUMENT;
+            LOG_WARN("value node is NULL", K(ret));
+          } else if (T_DEFAULT == set_node->children_[1]->type_) {
+            // set system_variable = default
+            var_node.is_set_default_ = true;
+          } else if (var_node.is_system_variable_) {
+            ParseNode value_node;
+            if (T_IDENT == set_node->children_[1]->type_) {
+              MEMCPY(&value_node, set_node->children_[1], sizeof(ParseNode));
+              value_node.type_ = T_VARCHAR;
+            } else if (T_COLUMN_REF == set_node->children_[1]->type_) {
+              if (NULL == set_node->children_[1]->children_[0] && NULL == set_node->children_[1]->children_[1] &&
+                  NULL != set_node->children_[1]->children_[2]) {
+                MEMCPY(&value_node, set_node->children_[1]->children_[2], sizeof(ParseNode));
+                value_node.type_ = T_VARCHAR;
+              } else {
+                MEMCPY(&value_node, set_node->children_[1], sizeof(ParseNode));
+              }
+            } else if (T_OBJ_ACCESS_REF == set_node->children_[1]->type_) {  // Oracle mode
+              if (OB_ISNULL(set_node->children_[1]->children_[0]) ||
+                  OB_UNLIKELY(set_node->children_[1]->children_[1] != NULL)) {
+                ret = OB_NOT_SUPPORTED;
+                LOG_USER_ERROR(OB_NOT_SUPPORTED, "Variable value not a varchar nor identifier type");
+              } else {
+                MEMCPY(&value_node, set_node->children_[1]->children_[0], sizeof(ParseNode));
+              }
+
+              if (OB_SUCC(ret)) {
+                if (T_IDENT == set_node->children_[1]->children_[0]->type_) {
+                  value_node.type_ = T_VARCHAR;
+                } else if (T_FUN_SYS == set_node->children_[1]->children_[0]->type_) {
+                  // do nothing
+                } else {
+                  ret = OB_NOT_SUPPORTED;
+                  LOG_USER_ERROR(OB_NOT_SUPPORTED, "Variable value type");
+                }
+              }
+            } else {
+              MEMCPY(&value_node, set_node->children_[1], sizeof(ParseNode));
+            }
+            if (OB_SUCC(ret)) {
+              if (0 == var_node.variable_name_.case_compare("ob_compatibility_mode") &&
+                  0 == strncasecmp(
+                           value_node.str_value_, "oracle", std::min(static_cast<int32_t>(value_node.str_len_), 6))) {
+                ret = OB_NOT_SUPPORTED;
+                LOG_USER_ERROR(OB_NOT_SUPPORTED, "Not support oracle mode");
+              } else if (OB_FAIL(
+                             ObResolverUtils::resolve_const_expr(params_, value_node, var_node.value_expr_, NULL))) {
+                LOG_WARN("resolve variable value failed", K(ret));
+              }
+            }
+          } else {
+            if (OB_FAIL(ObResolverUtils::resolve_const_expr(
+                    params_, *set_node->children_[1], var_node.value_expr_, NULL))) {
+              LOG_WARN("resolve variable value failed", K(ret));
+            }
+          }
+          if (OB_SUCC(ret) && OB_FAIL(variable_set_stmt->add_variable_node(var_node))) {
+            LOG_WARN("Add set entry failed", K(ret));
+          }
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+ObAlterSessionSetResolver::ObAlterSessionSetResolver(ObResolverParams& params) : ObStmtResolver(params)
+{}
+
+ObAlterSessionSetResolver::~ObAlterSessionSetResolver()
+{}
+
+// for oracle mode grammer: alter session set sys_var = val
+int ObAlterSessionSetResolver::resolve(const ParseNode& parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ObVariableSetStmt* variable_set_stmt = NULL;
+  if (OB_UNLIKELY(T_ALTER_SESSION_SET != parse_tree.type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("parse_tree.type_ must be T_ALTER_SESSION_SET", K(ret), K(parse_tree.type_));
+  } else if (OB_ISNULL(session_info_) || OB_ISNULL(allocator_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("session_info_ or allocator_ is NULL", K(ret), K(session_info_), K(allocator_));
+  } else if (OB_ISNULL(variable_set_stmt = create_stmt<ObVariableSetStmt>())) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_ERROR("create variable set stmt failed", K(ret));
+  } else {
+    // start resolve
+    stmt_ = variable_set_stmt;
+    variable_set_stmt->set_actual_tenant_id(session_info_->get_effective_tenant_id());
+    ParseNode* set_clause_node = NULL;
+    ParseNode* set_param_node = NULL;
+    ObVariableSetStmt::VariableSetNode var_node;
+    // resolve alter_session_set_clause
+    if (OB_ISNULL(set_clause_node = parse_tree.children_[0])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("set_clause_node is NULL", K(ret));
+    } else if (T_ALTER_SESSION_SET_PARAMETER_LIST != set_clause_node->type_) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("set_node->type_ must be T_ALTER_SESSION_SET_PARAMETER_LIST", K(ret), K(set_clause_node->type_));
+    } else {
+      // resolve set_system_parameter_clause_list
+      for (int64_t i = 0; OB_SUCC(ret) && i < set_clause_node->num_child_; ++i) {
+        if (OB_ISNULL(set_param_node = set_clause_node->children_[i])) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("set_param_node is null", K(ret));
+        } else if (T_VAR_VAL != set_param_node->type_) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("set_node->type_ must be T_VAR_VAL", K(ret), K(set_param_node->type_));
+        } else {
+          // resolve set_system_parameter_clause
+          ParseNode* var = NULL;
+          var_node.set_scope_ = ObSetVar::SET_SCOPE_SESSION;
+          if (OB_ISNULL(var = set_param_node->children_[0])) {
+            ret = OB_ERR_UNEXPECTED;
+            LOG_WARN("var is NULL", K(ret));
+          } else {
+            // resolve variable
+            ObString var_name;
+            if (T_IDENT != var->type_) {
+              ret = OB_NOT_SUPPORTED;
+              LOG_USER_ERROR(OB_NOT_SUPPORTED, "Variable name not an identifier type");
+            } else {
+              var_node.is_system_variable_ = true;
+              var_name.assign_ptr(var->str_value_, static_cast<int32_t>(var->str_len_));
+            }
+            if (OB_SUCC(ret)) {
+              if (OB_FAIL(ob_write_string(*allocator_, var_name, var_node.variable_name_))) {
+                LOG_WARN("Can not malloc space for variable name", K(ret));
+              } else {
+                ObCharset::casedn(CS_TYPE_UTF8MB4_GENERAL_CI, var_node.variable_name_);
+              }
+            }
+            // resolve value
+            if (OB_SUCC(ret)) {
+              if (OB_ISNULL(set_param_node->children_[1])) {
+                ret = OB_INVALID_ARGUMENT;
+                LOG_WARN("value node is NULL", K(ret));
+              } else if (var_node.is_system_variable_) {
+                ParseNode value_node;
+                MEMCPY(&value_node, set_param_node->children_[1], sizeof(ParseNode));
+                if (OB_FAIL(ObResolverUtils::resolve_const_expr(params_, value_node, var_node.value_expr_, NULL))) {
+                  LOG_WARN("resolve variable value failed", K(ret));
+                }
+              }
+            }
+          }
+          if (OB_SUCC(ret) && OB_FAIL(variable_set_stmt->add_variable_node(var_node))) {
+            LOG_WARN("Add set entry failed", K(ret));
+          }
+        }
+      }  // end for
+    }
+  }
+  return ret;
+}
+
+}  // namespace sql
+}  // namespace oceanbase

src/sql/resolver/cmd/ob_variable_set_resolver.h

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_OB_VARIALBLE_SET_RESOLVER_
+#define OCEANBASE_SQL_RESOLVER_CMD_OB_VARIALBLE_SET_RESOLVER_
+
+#include "sql/resolver/ob_stmt_resolver.h"
+
+namespace oceanbase {
+namespace sql {
+class ObVariableSetResolver : public ObStmtResolver {
+  public:
+  explicit ObVariableSetResolver(ObResolverParams& params);
+  virtual ~ObVariableSetResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObVariableSetResolver);
+};
+
+class ObAlterSessionSetResolver : public ObStmtResolver {
+  public:
+  explicit ObAlterSessionSetResolver(ObResolverParams& params);
+  virtual ~ObAlterSessionSetResolver();
+
+  virtual int resolve(const ParseNode& parse_tree);
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(ObAlterSessionSetResolver);
+};
+
+}  // namespace sql
+}  // namespace oceanbase
+#endif /* OCEANBASE_SQL_RESOLVER_CMD_OB_VARIALBLE_SET_RESOLVER_ */

src/sql/resolver/cmd/ob_variable_set_stmt.cpp

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#define USING_LOG_PREFIX SQL_RESV
+#include "sql/resolver/cmd/ob_variable_set_stmt.h"
+
+namespace oceanbase {
+using namespace common;
+namespace sql {
+int ObVariableSetStmt::get_variable_node(int64_t index, ObVariableSetStmt::VariableSetNode& var_node) const
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(index < 0 || index >= variable_nodes_.count())) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid index", K(index), K(ret));
+  } else if (OB_FAIL(variable_nodes_.at(index, var_node))) {
+    LOG_WARN("fail to get variable_nodes", K(index), K(ret));
+  } else {
+  }
+  return ret;
+}
+
+}  // end of namespace sql
+}  // end of namespace oceanbase

src/sql/resolver/cmd/ob_variable_set_stmt.h

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_SQL_RESOLVER_CMD_VARIABLE_SET_STMT_
+#define OCEANBASE_SQL_RESOLVER_CMD_VARIABLE_SET_STMT_
+
+#include "lib/string/ob_string.h"
+#include "lib/container/ob_array.h"
+#include "sql/resolver/ddl/ob_ddl_stmt.h"
+#include "share/system_variable/ob_system_variable.h"
+
+namespace oceanbase {
+namespace sql {
+class ObVariableSetStmt : public ObDDLStmt {
+  public:
+  class VariableSetNode {
+    public:
+    VariableSetNode()
+        : variable_name_(),
+          is_system_variable_(false),
+          set_scope_(share::ObSetVar::SET_SCOPE_NEXT_TRANS),
+          value_expr_(NULL),
+          is_set_default_(false)
+    {}
+    virtual ~VariableSetNode()
+    {}
+    TO_STRING_KV(K_(variable_name), K_(is_system_variable), K_(set_scope), K_(value_expr), K_(is_set_default));
+
+    common::ObString variable_name_;
+    bool is_system_variable_;
+    share::ObSetVar::SetScopeType set_scope_;
+    ObRawExpr* value_expr_;
+    bool is_set_default_;
+  };
+
+  ObVariableSetStmt()
+      : ObDDLStmt(stmt::T_VARIABLE_SET),
+        actual_tenant_id_(common::OB_INVALID_ID),
+        variable_nodes_(),
+        has_global_variable_(false)
+  {}
+  virtual ~ObVariableSetStmt()
+  {}
+
+  inline void set_actual_tenant_id(uint64_t actual_tenant_id)
+  {
+    actual_tenant_id_ = actual_tenant_id;
+  }
+  inline uint64_t get_actual_tenant_id() const
+  {
+    return actual_tenant_id_;
+  }
+  inline int add_variable_node(const VariableSetNode& node);
+  inline int64_t get_variables_size() const;
+  int get_variable_node(int64_t index, VariableSetNode& node) const;
+  inline void set_has_global_variable(bool has_global_variable)
+  {
+    has_global_variable_ = has_global_variable;
+  }
+  inline bool has_global_variable() const
+  {
+    return has_global_variable_;
+  }
+
+  virtual int get_cmd_type() const
+  {
+    return get_stmt_type();
+  }
+  virtual bool cause_implicit_commit() const
+  {
+    /* when VariableSet is SET AUTOCOMMIT=? statement,
+     * and autocommit turns from 0 to 1,
+     * it cause implicit commit in its executor.
+     * Other set statement do not trigger implicit commit.
+     * If it does, SET AUTOCOMMIT should use another new stmt
+     */
+    return false;
+  }
+
+  const common::ObIArray<VariableSetNode>& get_variable_nodes() const
+  {
+    return variable_nodes_;
+  }
+  virtual obrpc::ObDDLArg& get_ddl_arg()
+  {
+    return modify_sysvar_arg_;
+  }
+  TO_STRING_KV(K_(actual_tenant_id), K_(variable_nodes));
+
+  private:
+  uint64_t actual_tenant_id_;
+  common::ObArray<VariableSetNode, common::ModulePageAllocator, true> variable_nodes_;
+  bool has_global_variable_;
+  obrpc::ObModifySysVarArg modify_sysvar_arg_;
+  DISALLOW_COPY_AND_ASSIGN(ObVariableSetStmt);
+};
+
+inline int ObVariableSetStmt::add_variable_node(const VariableSetNode& node)
+{
+  return variable_nodes_.push_back(node);
+}
+
+inline int64_t ObVariableSetStmt::get_variables_size() const
+{
+  return variable_nodes_.count();
+}
+}  // end of namespace sql
+}  // end of namespace oceanbase
+
+#endif  // OCEANBASE_SQL_RESOLVER_CMD_VARIABLE_SET_STMT_