[FEAT MERGE] Implement tenant cloning mechanism

Co-authored-by: lalalafeier <wufeifei2023@163.com>
Co-authored-by: wanyue-wy <345657357@qq.com>
Co-authored-by: joseph12138 <17862707376@163.com>

src/sql/resolver/cmd/ob_alter_system_resolver.cpp

@@ -6011,5 +6011,64 @@ int ObAlterSystemResetResolver::resolve(const ParseNode &parse_tree)
   return ret;
 }
 
+int ObCancelCloneResolver::resolve(const ParseNode &parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode *node = const_cast<ParseNode*>(&parse_tree);
+  ObCancelCloneStmt *mystmt = NULL;
+  ObString tenant_name;
+
+  if (OB_ISNULL(node)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_UNLIKELY(T_CANCEL_CLONE != node->type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_UNLIKELY(1 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_ISNULL(session_info_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("session info should not be null", KR(ret));
+  } else {
+    bool is_compatible = false;
+    const uint64_t tenant_id = session_info_->get_login_tenant_id();
+    if (OB_FAIL(share::ObShareUtil::check_compat_version_for_clone_tenant(tenant_id, is_compatible))) {
+      LOG_WARN("fail to check compat version", KR(ret), K(tenant_id));
+    } else if (!is_compatible) {
+      ret = OB_NOT_SUPPORTED;
+      LOG_WARN("tenant data version is below 4.3", KR(ret), K(tenant_id), K(is_compatible));
+      LOG_USER_ERROR(OB_NOT_SUPPORTED, "cancel tenant cloning below 4.3");
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_ISNULL(mystmt = create_stmt<ObCancelCloneStmt>())) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create stmt", KR(ret));
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_ISNULL(node->children_[0])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else if (OB_UNLIKELY(T_IDENT != node->children_[0]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else {
+      tenant_name.assign_ptr((char *)(node->children_[0]->str_value_),
+                                  static_cast<int32_t>(node->children_[0]->str_len_));
+      if (OB_FAIL(mystmt->set_clone_tenant_name(tenant_name))) {
+        LOG_WARN("set clone tenant name failed", KR(ret), K(tenant_name));
+      }
+    }
+  }
+
+  return ret;
+}
+
 } // end namespace sql
 } // end namespace oceanbase

src/sql/resolver/cmd/ob_alter_system_resolver.h

@@ -304,6 +304,7 @@ private:
 };
 
 DEF_SIMPLE_CMD_RESOLVER(ObTableTTLResolver);
+DEF_SIMPLE_CMD_RESOLVER(ObCancelCloneResolver);
 
 #undef DEF_SIMPLE_CMD_RESOLVER
 

src/sql/resolver/cmd/ob_alter_system_stmt.h

@@ -1351,6 +1351,20 @@ private:
   obrpc::ObAdminSetConfigArg rpc_arg_;
 };
 
+class ObCancelCloneStmt : public ObSystemCmdStmt
+{
+public:
+  ObCancelCloneStmt()
+    : ObSystemCmdStmt(stmt::T_CANCEL_CLONE),
+      clone_tenant_name_() {}
+  virtual ~ObCancelCloneStmt() {}
+  int set_clone_tenant_name(const ObString &tenant_name) { return clone_tenant_name_.assign(tenant_name); }
+  const ObString get_clone_tenant_name() { return clone_tenant_name_.str(); }
+	TO_STRING_KV(N_STMT_TYPE, ((int)stmt_type_), K_(clone_tenant_name));
+private:
+  common::ObFixedLengthString<common::OB_MAX_TENANT_NAME_LENGTH + 1> clone_tenant_name_;
+};
+
 } // end namespace sql
 } // end namespace oceanbase
 

src/sql/resolver/cmd/ob_tenant_clone_resolver.cpp

@@ -0,0 +1,205 @@
+/**
+ * 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_tenant_clone_stmt.h"
+#include "sql/resolver/cmd/ob_tenant_clone_resolver.h"
+#include "sql/resolver/ob_resolver_utils.h"
+
+namespace oceanbase
+{
+using namespace common;
+using namespace share::schema;
+namespace sql
+{
+
+ObCloneTenantResolver::ObCloneTenantResolver(ObResolverParams &params)
+  : ObCMDResolver(params)
+{
+}
+
+ObCloneTenantResolver::~ObCloneTenantResolver()
+{
+}
+
+int ObCloneTenantResolver::resolve(const ParseNode &parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode *node = const_cast<ParseNode*>(&parse_tree);
+  ObCloneTenantStmt *mystmt = NULL;
+  ObString new_tenant_name;
+  ObString source_tenant_name;
+  ObString tenant_snapshot_name;
+  ObString resource_pool_name;
+  ObString unit_config_name;
+
+  if (OB_ISNULL(node)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_UNLIKELY(T_CLONE_TENANT != node->type_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_UNLIKELY(5 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_ISNULL(session_info_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("session info should not be null", KR(ret));
+  } else {
+    bool is_compatible = false;
+    const uint64_t tenant_id = session_info_->get_login_tenant_id();
+    if (OB_FAIL(share::ObShareUtil::check_compat_version_for_clone_tenant(tenant_id, is_compatible))) {
+      LOG_WARN("fail to check compat version", KR(ret), K(tenant_id));
+    } else if (!is_compatible) {
+      ret = OB_NOT_SUPPORTED;
+      LOG_WARN("tenant data version is below 4.3", KR(ret), K(tenant_id), K(is_compatible));
+      LOG_USER_ERROR(OB_NOT_SUPPORTED, "clone tenant below 4.3");
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObCloneTenantStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* if not exist */
+  if (OB_SUCC(ret)) {
+    if (NULL != parse_tree.children_[0]) {
+      if (OB_UNLIKELY(T_IF_NOT_EXISTS != parse_tree.children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else {
+        mystmt->set_if_not_exists(true);
+      }
+    } else {
+      mystmt->set_if_not_exists(false);
+    }
+  }
+
+  /* new tenant name */
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[1])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else if (OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else {
+      new_tenant_name.assign_ptr((char *)(node->children_[1]->str_value_),
+                                  static_cast<int32_t>(node->children_[1]->str_len_));
+      if (OB_FAIL(ObResolverUtils::check_not_supported_tenant_name(new_tenant_name))) {
+        LOG_WARN("unsupported tenant name", KR(ret), K(new_tenant_name));
+      }
+    }
+  }
+
+  /* source tenant name */
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[2])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else if (OB_UNLIKELY(T_IDENT != node->children_[2]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else {
+      source_tenant_name.assign_ptr((char *)(node->children_[2]->str_value_),
+                                     static_cast<int32_t>(node->children_[2]->str_len_));
+    }
+  }
+
+  /* tenant snapshot name */
+  if (OB_SUCC(ret)) {
+    if (NULL == node->children_[3]) {
+    } else if (OB_UNLIKELY(T_IDENT != node->children_[3]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else {
+      tenant_snapshot_name.assign_ptr((char *)(node->children_[3]->str_value_),
+                                       static_cast<int32_t>(node->children_[3]->str_len_));
+    }
+  }
+
+  /* clone option list */
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == node->children_[4])) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else if (OB_UNLIKELY(T_LINK_NODE != node->children_[4]->type_)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_ERROR("invalid node", KR(ret));
+    } else {
+      if (OB_FAIL(resolve_option_list_(node->children_[4], resource_pool_name, unit_config_name))) {
+        LOG_WARN("resolve option list failed", KR(ret));
+      } else if (resource_pool_name.empty()) {
+        ret = OB_NOT_SUPPORTED;
+        LOG_WARN("resource pool name is empty", KR(ret));
+        LOG_USER_ERROR(OB_NOT_SUPPORTED, "clone tenant without resource pool");
+      } else if (unit_config_name.empty()) {
+        ret = OB_NOT_SUPPORTED;
+        LOG_WARN("unit config name is empty", KR(ret));
+        LOG_USER_ERROR(OB_NOT_SUPPORTED, "clone tenant without unit config");
+      }
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_FAIL(mystmt->init(new_tenant_name, source_tenant_name,
+          tenant_snapshot_name, resource_pool_name, unit_config_name))) {
+      LOG_WARN("mystmt init failed", KR(ret), K(new_tenant_name), K(source_tenant_name),
+          K(tenant_snapshot_name), K(resource_pool_name), K(unit_config_name));
+    }
+  }
+
+  return ret;
+}
+
+int ObCloneTenantResolver::resolve_option_list_(const ParseNode *node,
+                                                ObString &resource_pool_name,
+                                                ObString &unit_config_name)
+{
+  int ret = OB_SUCCESS;
+
+  if (OB_UNLIKELY(NULL == node)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else if (OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid node", KR(ret));
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; i++) {
+      const ParseNode *option_node = node->children_[i];
+      if (OB_UNLIKELY(NULL == option_node)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else if (OB_UNLIKELY(1 != option_node->num_child_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else if (T_RESOURCE_POOL_LIST == option_node->type_) {
+        resource_pool_name.assign_ptr((char *)(option_node->children_[0]->str_value_),
+                              static_cast<int32_t>(option_node->children_[0]->str_len_));
+      } else if (T_UNIT == option_node->type_) {
+        unit_config_name.assign_ptr((char *)(option_node->children_[0]->str_value_),
+                              static_cast<int32_t>(option_node->children_[0]->str_len_));
+      }
+    }
+  }
+
+  return ret;
+}
+
+}
+}

src/sql/resolver/cmd/ob_tenant_clone_resolver.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 _OB_CLONE_TENANT_RESOLVER_H
+#define _OB_CLONE_TENANT_RESOLVER_H
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+namespace oceanbase
+{
+namespace sql
+{
+class ObCloneTenantResolver : public ObCMDResolver
+{
+public:
+  explicit ObCloneTenantResolver(ObResolverParams &params);
+  virtual ~ObCloneTenantResolver();
+
+  virtual int resolve(const ParseNode &parse_tree);
+private:
+  int resolve_option_list_(const ParseNode *node,
+                           ObString &resource_pool_name,
+                           ObString &unit_config_name);
+private:
+  DISALLOW_COPY_AND_ASSIGN(ObCloneTenantResolver);
+};
+
+}
+}
+
+#endif /*_OB_CREATE_SNAPSHOT_RESOLVER_H*/

src/sql/resolver/cmd/ob_tenant_clone_stmt.h

@@ -0,0 +1,62 @@
+/**
+ * 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_CLONE_TENANT_STMT_H_
+#define OCEANBASE_SQL_OB_CLONE_TENANT_STMT_H_
+
+#include "sql/resolver/cmd/ob_cmd_stmt.h"
+
+namespace oceanbase
+{
+namespace sql
+{
+
+class ObCloneTenantStmt : public ObCMDStmt
+{
+public:
+  explicit ObCloneTenantStmt(common::ObIAllocator *name_pool)
+    : ObCMDStmt(name_pool, stmt::T_CLONE_TENANT),
+      clone_tenant_arg_(),
+      if_not_exists_(false) {}
+  ObCloneTenantStmt()
+    : ObCMDStmt(stmt::T_CLONE_TENANT),
+      clone_tenant_arg_(),
+      if_not_exists_(false) {}
+  virtual ~ObCloneTenantStmt() {}
+  inline obrpc::ObCloneTenantArg &get_clone_tenant_arg() { return clone_tenant_arg_; }
+  inline bool get_if_not_exists() const { return if_not_exists_; }
+  int init(const ObString &new_tenant_name,
+           const ObString &source_tenant_name,
+           const ObString &tenant_snapshot_name,
+           const ObString &resource_pool_name,
+           const ObString &unit_config_name)
+  {
+    return clone_tenant_arg_.init(new_tenant_name,
+                                  source_tenant_name,
+                                  tenant_snapshot_name,
+                                  resource_pool_name,
+                                  unit_config_name);
+  }
+  void set_if_not_exists(const bool is_exist)
+  {
+    if_not_exists_ = is_exist;
+  }
+private:
+  obrpc::ObCloneTenantArg clone_tenant_arg_;
+  bool if_not_exists_;
+  DISALLOW_COPY_AND_ASSIGN(ObCloneTenantStmt);
+};
+
+} /* sql */
+} /* oceanbase */
+
+#endif //OCEANBASE_SQL_OB_CLONE_TENANT_STMT_H_

src/sql/resolver/cmd/ob_tenant_snapshot_resolver.cpp

@@ -0,0 +1,200 @@
+/**
+ * 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_tenant_snapshot_stmt.h"
+#include "sql/resolver/cmd/ob_tenant_snapshot_resolver.h"
+#include "sql/session/ob_sql_session_info.h"
+#include "share/ob_share_util.h"
+
+namespace oceanbase
+{
+using namespace common;
+using namespace share::schema;
+namespace sql
+{
+
+ObCreateTenantSnapshotResolver::ObCreateTenantSnapshotResolver(ObResolverParams &params)
+  : ObCMDResolver(params)
+{
+}
+
+ObCreateTenantSnapshotResolver::~ObCreateTenantSnapshotResolver()
+{
+}
+
+int ObCreateTenantSnapshotResolver::resolve(const ParseNode &parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode *node = const_cast<ParseNode*>(&parse_tree);
+  ObCreateTenantSnapshotStmt *mystmt = NULL;
+  uint64_t tenant_id = OB_INVALID_TENANT_ID;
+
+  if (OB_ISNULL(node)
+      || OB_UNLIKELY(T_CREATE_TENANT_SNAPSHOT != node->type_)
+      || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid param", KR(ret));
+  } else if (OB_ISNULL(session_info_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("session info should not be null", KR(ret));
+  } else {
+    bool is_compatible = false;
+    tenant_id = session_info_->get_login_tenant_id();
+    if (OB_FAIL(share::ObShareUtil::check_compat_version_for_clone_tenant(tenant_id, is_compatible))) {
+      LOG_WARN("fail to check compat version", KR(ret), K(tenant_id));
+    } else if (!is_compatible) {
+      ret = OB_NOT_SUPPORTED;
+      LOG_WARN("tenant data version is below 4.3", KR(ret), K(tenant_id), K(is_compatible));
+      LOG_USER_ERROR(OB_NOT_SUPPORTED, "create tenant snapshot below 4.3");
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObCreateTenantSnapshotStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* snapshot name */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[0]) {
+      if (OB_UNLIKELY(T_IDENT != node->children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else {
+        ObString snapshot_name;
+        snapshot_name.assign_ptr((char *)(node->children_[0]->str_value_),
+                              static_cast<int32_t>(node->children_[0]->str_len_));
+        if (OB_FAIL(mystmt->set_tenant_snapshot_name(snapshot_name))) {
+          LOG_WARN("fail to set tenant snapshot name", KR(ret), K(snapshot_name));
+        }
+      }
+    } else {
+      //create snapshot name later
+    }
+  }
+
+   /* tenant name */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[1]) {
+      if (OB_SYS_TENANT_ID != tenant_id) {
+        ret = OB_ERR_NO_PRIVILEGE;
+        LOG_WARN("Only sys tenant can add suffix opt(for tenant name)", KR(ret), K(tenant_id));
+      } else if (OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else {
+        ObString tenant_name;
+        tenant_name.assign_ptr((char *)(node->children_[1]->str_value_),
+                              static_cast<int32_t>(node->children_[1]->str_len_));
+        if (OB_FAIL(mystmt->set_tenant_name(tenant_name))) {
+          LOG_WARN("fail to set tenant name", KR(ret), K(tenant_name));
+        }
+      }
+    }
+  }
+
+  return ret;
+}
+
+ObDropTenantSnapshotResolver::ObDropTenantSnapshotResolver(ObResolverParams &params)
+  : ObCMDResolver(params)
+{
+}
+
+ObDropTenantSnapshotResolver::~ObDropTenantSnapshotResolver()
+{
+}
+
+int ObDropTenantSnapshotResolver::resolve(const ParseNode &parse_tree)
+{
+  int ret = OB_SUCCESS;
+  ParseNode *node = const_cast<ParseNode*>(&parse_tree);
+  ObDropTenantSnapshotStmt *mystmt = NULL;
+  uint64_t tenant_id = OB_INVALID_TENANT_ID;
+
+  if (OB_ISNULL(node)
+      || OB_UNLIKELY(T_DROP_TENANT_SNAPSHOT != node->type_)
+      || OB_UNLIKELY(2 != node->num_child_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("invalid param", KR(ret));
+  } else if (OB_ISNULL(session_info_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("session info should not be null", KR(ret));
+  } else {
+    bool is_compatible = false;
+    tenant_id = session_info_->get_login_tenant_id();
+    if (OB_FAIL(share::ObShareUtil::check_compat_version_for_clone_tenant(tenant_id, is_compatible))) {
+      LOG_WARN("fail to check compat version", KR(ret), K(tenant_id));
+    } else if (!is_compatible) {
+      ret = OB_NOT_SUPPORTED;
+      LOG_WARN("tenant data version is below 4.3", KR(ret), K(tenant_id), K(is_compatible));
+      LOG_USER_ERROR(OB_NOT_SUPPORTED, "drop tenant snapshot below 4.3");
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    if (OB_UNLIKELY(NULL == (mystmt = create_stmt<ObDropTenantSnapshotStmt>()))) {
+      ret = OB_ALLOCATE_MEMORY_FAILED;
+      LOG_ERROR("failed to create stmt");
+    } else {
+      stmt_ = mystmt;
+    }
+  }
+
+  /* snapshot name */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[0]) {
+      if (OB_UNLIKELY(T_IDENT != node->children_[0]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else {
+        ObString snapshot_name;
+        snapshot_name.assign_ptr((char *)(node->children_[0]->str_value_),
+                              static_cast<int32_t>(node->children_[0]->str_len_));
+        if (OB_FAIL(mystmt->set_tenant_snapshot_name(snapshot_name))) {
+          LOG_WARN("fail to set tenant snapshot name", KR(ret), K(snapshot_name));
+        }
+      }
+    }
+  }
+
+   /* tenant name */
+  if (OB_SUCC(ret)) {
+    if (NULL != node->children_[1]) {
+      if (OB_SYS_TENANT_ID != tenant_id) {
+        ret = OB_ERR_NO_PRIVILEGE;
+        LOG_WARN("Only sys tenant can add suffix opt(for tenant name)", KR(ret), K(tenant_id));
+      } else if (OB_UNLIKELY(T_IDENT != node->children_[1]->type_)) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_ERROR("invalid node", KR(ret));
+      } else {
+        ObString tenant_name;
+        tenant_name.assign_ptr((char *)(node->children_[1]->str_value_),
+                              static_cast<int32_t>(node->children_[1]->str_len_));
+        if (OB_FAIL(mystmt->set_tenant_name(tenant_name))) {
+          LOG_WARN("fail to set tenant name", KR(ret), K(tenant_name));
+        }
+      }
+    }
+  }
+
+  return ret;
+}
+
+}
+}

src/sql/resolver/cmd/ob_tenant_snapshot_resolver.h

@@ -0,0 +1,47 @@
+/**
+ * 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_TENANT_SNAPSHOT_RESOLVER_H
+#define _OB_TENANT_SNAPSHOT_RESOLVER_H
+
+#include "sql/resolver/cmd/ob_cmd_resolver.h"
+
+namespace oceanbase
+{
+namespace sql
+{
+class ObCreateTenantSnapshotResolver : public ObCMDResolver
+{
+public:
+  explicit ObCreateTenantSnapshotResolver(ObResolverParams &params);
+  virtual ~ObCreateTenantSnapshotResolver();
+
+  virtual int resolve(const ParseNode &parse_tree);
+private:
+  DISALLOW_COPY_AND_ASSIGN(ObCreateTenantSnapshotResolver);
+};
+
+class ObDropTenantSnapshotResolver : public ObCMDResolver
+{
+public:
+  explicit ObDropTenantSnapshotResolver(ObResolverParams &params);
+  virtual ~ObDropTenantSnapshotResolver();
+
+  virtual int resolve(const ParseNode &parse_tree);
+private:
+  DISALLOW_COPY_AND_ASSIGN(ObDropTenantSnapshotResolver);
+};
+
+} // end namespace sql
+} // end namespace oceanbase
+
+#endif /*_OB_TENANT_SNAPSHOT_RESOLVER_H*/

src/sql/resolver/cmd/ob_tenant_snapshot_stmt.h

@@ -0,0 +1,88 @@
+/**
+ * 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_TENANT_SNAPSHOT_STMT_H_
+#define OCEANBASE_SQL_OB_TENANT_SNAPSHOT_STMT_H_
+
+#include "sql/resolver/cmd/ob_cmd_stmt.h"
+
+namespace oceanbase
+{
+namespace sql
+{
+
+class ObCreateTenantSnapshotStmt : public ObCMDStmt
+{
+public:
+  explicit ObCreateTenantSnapshotStmt(common::ObIAllocator *name_pool)
+    : ObCMDStmt(name_pool, stmt::T_CREATE_TENANT_SNAPSHOT),
+      tenant_name_(),
+      tenant_snapshot_name_()
+      {}
+  ObCreateTenantSnapshotStmt()
+    : ObCMDStmt(stmt::T_CREATE_TENANT_SNAPSHOT),
+      tenant_name_(),
+      tenant_snapshot_name_()
+      {}
+  virtual ~ObCreateTenantSnapshotStmt() {}
+  const common::ObString get_tenant_name() const { return tenant_name_.str(); }
+  const common::ObString get_tenant_snapshot_name() const { return tenant_snapshot_name_.str(); }
+
+  int set_tenant_name(const common::ObString &tenant_name)
+  {
+    return tenant_name_.assign(tenant_name);
+  }
+  int set_tenant_snapshot_name(const common::ObString &tenant_snapshot_name)
+  {
+    return tenant_snapshot_name_.assign(tenant_snapshot_name);
+  }
+private:
+  common::ObFixedLengthString<common::OB_MAX_TENANT_NAME_LENGTH + 1> tenant_name_;
+  common::ObFixedLengthString<common::OB_MAX_TENANT_SNAPSHOT_NAME_LENGTH + 1> tenant_snapshot_name_;
+  DISALLOW_COPY_AND_ASSIGN(ObCreateTenantSnapshotStmt);
+};
+
+class ObDropTenantSnapshotStmt : public ObCMDStmt
+{
+public:
+  explicit ObDropTenantSnapshotStmt(common::ObIAllocator *name_pool)
+    : ObCMDStmt(name_pool, stmt::T_DROP_TENANT_SNAPSHOT),
+      tenant_name_(),
+      tenant_snapshot_name_()
+      {}
+  ObDropTenantSnapshotStmt()
+    : ObCMDStmt(stmt::T_DROP_TENANT_SNAPSHOT),
+      tenant_name_(),
+      tenant_snapshot_name_()
+      {}
+  virtual ~ObDropTenantSnapshotStmt() {}
+  const common::ObString get_tenant_name() const { return tenant_name_.str(); }
+  const common::ObString get_tenant_snapshot_name() const { return tenant_snapshot_name_.str(); }
+
+  int set_tenant_name(const common::ObString &tenant_name)
+  {
+    return tenant_name_.assign(tenant_name);
+  }
+  int set_tenant_snapshot_name(const common::ObString &tenant_snapshot_name)
+  {
+    return tenant_snapshot_name_.assign(tenant_snapshot_name);
+  }
+private:
+  common::ObFixedLengthString<common::OB_MAX_TENANT_NAME_LENGTH + 1> tenant_name_;
+  common::ObFixedLengthString<common::OB_MAX_TENANT_SNAPSHOT_NAME_LENGTH + 1> tenant_snapshot_name_;
+  DISALLOW_COPY_AND_ASSIGN(ObDropTenantSnapshotStmt);
+};
+
+} /* sql */
+} /* oceanbase */
+
+#endif //OCEANBASE_SQL_OB_TENANT_SNAPSHOT_STMT_H_

src/sql/resolver/ob_resolver.cpp

@@ -131,6 +131,8 @@
 #include "pl/ob_pl_package.h"
 #include "sql/resolver/ddl/ob_create_context_resolver.h"
 #include "sql/resolver/ddl/ob_drop_context_resolver.h"
+#include "sql/resolver/cmd/ob_tenant_snapshot_resolver.h"
+#include "sql/resolver/cmd/ob_tenant_clone_resolver.h"
 #ifdef OB_BUILD_TDE_SECURITY
 #include "sql/resolver/ddl/ob_create_tablespace_resolver.h"
 #include "sql/resolver/ddl/ob_alter_tablespace_resolver.h"
@@ -1149,6 +1151,18 @@ int ObResolver::resolve(IsPrepared if_prepared, const ParseNode &parse_tree, ObS
         REGISTER_STMT_RESOLVER(TableTTL);
         break;
       }
+      case T_CREATE_TENANT_SNAPSHOT: {
+        REGISTER_STMT_RESOLVER(CreateTenantSnapshot);
+        break;
+      }
+      case T_DROP_TENANT_SNAPSHOT: {
+        REGISTER_STMT_RESOLVER(DropTenantSnapshot);
+        break;
+      }
+      case T_CLONE_TENANT: {
+        REGISTER_STMT_RESOLVER(CloneTenant);
+        break;
+      }
       case T_ALTER_SYSTEM_RESET_PARAMETER: {
         REGISTER_STMT_RESOLVER(ResetConfig);
         break;
@@ -1157,6 +1171,10 @@ int ObResolver::resolve(IsPrepared if_prepared, const ParseNode &parse_tree, ObS
         REGISTER_STMT_RESOLVER(AlterSystemReset);
         break;
       }
+      case T_CANCEL_CLONE: {
+        REGISTER_STMT_RESOLVER(CancelClone);
+        break;
+      }
       default: {
         ret = OB_NOT_SUPPORTED;
         const char *type_name = get_type_name(parse_tree.type_);

src/sql/resolver/ob_stmt_type.h

@@ -286,11 +286,11 @@ OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CANCEL_RESTORE, get_sys_tenant_alter_system_priv,
 OB_STMT_TYPE_DEF_UNKNOWN_AT(T_TABLE_TTL, get_sys_tenant_alter_system_priv, 287)
 OB_STMT_TYPE_DEF_UNKNOWN_AT(T_RECOVER_TABLE, get_sys_tenant_alter_system_priv, 288)
 OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CANCEL_RECOVER_TABLE, get_sys_tenant_alter_system_priv, 289)
-// OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CREATE_TENANT_SNAPSHOT, get_sys_tenant_alter_system_priv, 290)
-// OB_STMT_TYPE_DEF_UNKNOWN_AT(T_DROP_TENANT_SNAPSHOT, get_sys_tenant_alter_system_priv, 291)
+OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CREATE_TENANT_SNAPSHOT, get_sys_tenant_alter_system_priv, 290)
+OB_STMT_TYPE_DEF_UNKNOWN_AT(T_DROP_TENANT_SNAPSHOT, get_sys_tenant_alter_system_priv, 291)
 OB_STMT_TYPE_DEF(T_ALTER_SYSTEM_RESET_PARAMETER, get_sys_tenant_alter_system_priv, 292, ACTION_TYPE_ALTER_SYSTEM)
-// OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CLONE_TENANT, get_sys_tenant_alter_system_priv, 293)
-// OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CANCEL_CLONE, get_sys_tenant_alter_system_priv, 294)
+OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CLONE_TENANT, get_sys_tenant_alter_system_priv, 293)
+OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CANCEL_CLONE, get_sys_tenant_alter_system_priv, 294)
 // OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CREATE_MLOG, get_create_mlog_stmt_need_privs, 295)
 // OB_STMT_TYPE_DEF_UNKNOWN_AT(T_DROP_MLOG, get_drop_mlog_stmt_need_privs, 296)
 // OB_STMT_TYPE_DEF_UNKNOWN_AT(T_TRANSFER_PARTITION, get_sys_tenant_alter_system_priv, 297)