hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

patch back the flashback table/tenant/database/index(without flashback to scn)

Browse Source
This commit is contained in:
hnwyllmm
2022-02-14 10:53:44 +08:00
committed by LINxiansheng
parent a15a151dae
commit ac82728867
29 changed files with 989 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

315
src/sql/resolver/ddl/ob_flashback_resolver.cpp Normal file
View File

@ -0,0 +1,315 @@
/**
* 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 "share/ob_define.h"
#include "sql/resolver/ddl/ob_flashback_resolver.h"
#include "sql/resolver/ob_schema_checker.h"
#include "sql/session/ob_sql_session_info.h"
#include "rootserver/ob_ddl_service.h"
namespace oceanbase
{
using namespace common;
namespace sql
{
/**
* flashback table
*/
int ObFlashBackTableFromRecyclebinResolver::resolve(const ParseNode &parser_tree)
{
int ret = OB_SUCCESS;
ObFlashBackTableFromRecyclebinStmt *flashback_table_from_recyclebin_stmt = NULL;
if (OB_ISNULL(session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_info is null", K(ret));
} else if (T_FLASHBACK_TABLE_FROM_RECYCLEBIN != parser_tree.type_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(parser_tree.type_));
}
//create flashback table stmt
if (OB_SUCC(ret)) {
if (NULL == (flashback_table_from_recyclebin_stmt = create_stmt<ObFlashBackTableFromRecyclebinStmt>())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to create rename table stmt", K(ret));
} else {
stmt_ = flashback_table_from_recyclebin_stmt;
}
}
if (OB_SUCC(ret)) {
flashback_table_from_recyclebin_stmt->set_tenant_id(session_info_->get_effective_tenant_id());
//flashback table
ParseNode *table_node = parser_tree.children_[ORIGIN_TABLE_NODE];
ObString origin_table_name;
ObString origin_db_name;
if (OB_ISNULL(table_node)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table_node should not be null", K(ret));
} else if (OB_FAIL(resolve_table_relation_node(table_node,
origin_table_name,
origin_db_name,
true /*get origin db_name*/))) {
LOG_WARN("failed to resolve_table_relation_node", K(ret));
} else {
OX (flashback_table_from_recyclebin_stmt->set_origin_table_name(origin_table_name));
OX (flashback_table_from_recyclebin_stmt->set_origin_table_id(OB_INVALID_ID));
}
if (OB_SUCC(ret)) {
//rename to new table_name
ParseNode *rename_node = parser_tree.children_[NEW_TABLE_NODE];
if (NULL != rename_node) {
ObString new_table_name;
ObString new_db_name;
if (OB_FAIL(resolve_table_relation_node(rename_node,
new_table_name,
new_db_name))) {
LOG_WARN("failed to resolve_table_relation_node", K(ret));
} else if (ObString(OB_RECYCLEBIN_SCHEMA_NAME) == new_db_name
|| ObString(OB_PUBLIC_SCHEMA_NAME) == new_db_name) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("can't not flashback table to recyclebin database", K(ret));
} else {
flashback_table_from_recyclebin_stmt->set_new_db_name(new_db_name);
flashback_table_from_recyclebin_stmt->set_new_table_name(new_table_name);
}
}
}
// flashback table with origin table name from recyclebin is supported now
// reuse the unused origin_db_name to specify the database which the table was drop from
if (OB_SUCC(ret)) {
if (origin_db_name.empty()) {
if (OB_ISNULL(session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_info_ is null", K(ret));
} else {
flashback_table_from_recyclebin_stmt->set_origin_db_name(
session_info_->get_database_name());
}
} else {
flashback_table_from_recyclebin_stmt->set_origin_db_name(origin_db_name);
}
}
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(),
origin_db_name,
stmt::T_FLASHBACK_TABLE_FROM_RECYCLEBIN,
session_info_->get_enable_role_array()));
}
}
return ret;
}
/**
* flashback index
*/
int ObFlashBackIndexResolver::resolve(const ParseNode &parser_tree)
{
int ret = OB_SUCCESS;
ObFlashBackIndexStmt *flashback_index_stmt = NULL;
if (OB_ISNULL(session_info_) || OB_ISNULL(schema_checker_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_info or schema_checker is null", K(ret), K(schema_checker_), K(session_info_));
} else if (T_FLASHBACK_INDEX != parser_tree.type_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(parser_tree.type_));
}
//create flashback index stmt
if (OB_SUCC(ret)) {
if (NULL == (flashback_index_stmt = create_stmt<ObFlashBackIndexStmt>())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to create rename index stmt", K(ret));
} else {
stmt_ = flashback_index_stmt;
}
}
if (OB_SUCC(ret)) {
flashback_index_stmt->set_tenant_id(session_info_->get_effective_tenant_id());
//flashback table
ParseNode *table_node = parser_tree.children_[ORIGIN_TABLE_NODE];
ObString origin_table_name;
ObString origin_db_name;
const share::schema::ObTableSchema *table_schema = NULL;
if (OB_ISNULL(table_node)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table_node should not be null", K(ret));
} else if (OB_FAIL(resolve_table_relation_node(table_node,
origin_table_name,
origin_db_name,
true /*get origin db_name*/))) {
LOG_WARN("failed to resolve_table_relation_node", K(ret));
} else if (!origin_db_name.empty() && origin_db_name != OB_RECYCLEBIN_SCHEMA_NAME) {
ret = OB_TABLE_NOT_EXIST;
LOG_USER_ERROR(OB_TABLE_NOT_EXIST, to_cstring(origin_db_name), to_cstring(origin_table_name));
LOG_WARN("flashback index db.xx should not specified with db name", K(ret));
} else {
UNUSED(schema_checker_->get_table_schema(flashback_index_stmt->get_tenant_id(),
combine_id(flashback_index_stmt->get_tenant_id(), OB_RECYCLEBIN_SCHEMA_ID),
origin_table_name,
true, /*is_index*/
false, /*cte_table_fisrt*/
table_schema));
flashback_index_stmt->set_origin_table_name(origin_table_name);
flashback_index_stmt->set_origin_table_id(OB_NOT_NULL(table_schema) ? table_schema->get_table_id() : OB_INVALID_ID);
}
if (OB_SUCC(ret)) {
//rename to new table_name
ParseNode *rename_node = parser_tree.children_[NEW_TABLE_NODE];
if (NULL != rename_node) {
ObString new_index_name;
new_index_name.assign_ptr(rename_node->str_value_, static_cast<int32_t>(rename_node->str_len_));
flashback_index_stmt->set_new_table_name(new_index_name);
}
}
}
return ret;
}
/**
* flashback database
*/
int ObFlashBackDatabaseResolver::resolve(const ParseNode &parser_tree)
{
int ret = OB_SUCCESS;
ObFlashBackDatabaseStmt *flashback_database_stmt = NULL;
/**
* the length of database name should less than 127 bytes because of compatibility
*/
int32_t max_database_name_length = GET_MIN_CLUSTER_VERSION() < CLUSTER_CURRENT_VERSION ?
OB_MAX_DATABASE_NAME_LENGTH - 1 : OB_MAX_DATABASE_NAME_LENGTH;
if (OB_ISNULL(session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_info is null", K(ret));
} else if (T_FLASHBACK_DATABASE != parser_tree.type_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(parser_tree.type_));
}
//create flashback table stmt
if (OB_SUCC(ret)) {
if (NULL == (flashback_database_stmt = create_stmt<ObFlashBackDatabaseStmt>())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to create rename table stmt", K(ret));
} else {
stmt_ = flashback_database_stmt;
}
}
if (OB_SUCC(ret)) {
flashback_database_stmt->set_tenant_id(session_info_->get_effective_tenant_id());
ObString origin_db_name;
ParseNode *origin_dbname_node = parser_tree.children_[ORIGIN_DB_NODE];
if (OB_ISNULL(origin_dbname_node) || OB_UNLIKELY(T_IDENT != origin_dbname_node->type_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(ret));
} else if (OB_UNLIKELY(
static_cast<int32_t>(origin_dbname_node->str_len_) > max_database_name_length)) {
ret = OB_ERR_TOO_LONG_IDENT;
LOG_USER_ERROR(OB_ERR_TOO_LONG_IDENT, (int)origin_dbname_node->str_len_, origin_dbname_node->str_value_);
} else {
origin_db_name.assign_ptr(origin_dbname_node->str_value_,
static_cast<int32_t>(origin_dbname_node->str_len_));
flashback_database_stmt->set_origin_db_name(origin_db_name);
}
}
if (OB_SUCC(ret)) {
ParseNode *new_db_node = parser_tree.children_[NEW_DB_NODE];
if (NULL != new_db_node) {
ObString new_db_name;
if (OB_UNLIKELY(T_IDENT != new_db_node->type_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(ret));
} else if (OB_UNLIKELY(
static_cast<int32_t>(new_db_node->str_len_) > max_database_name_length)) {
ret = OB_ERR_TOO_LONG_IDENT;
LOG_USER_ERROR(OB_ERR_TOO_LONG_IDENT, (int)new_db_node->str_len_, new_db_node->str_value_);
} else {
new_db_name.assign_ptr(new_db_node->str_value_,
static_cast<int32_t>(new_db_node->str_len_));
flashback_database_stmt->set_new_db_name(new_db_name);
}
}
}
return ret;
}
/**
* flashback tenant
*/
int ObFlashBackTenantResolver::resolve(const ParseNode &parser_tree)
{
int ret = OB_SUCCESS;
ObFlashBackTenantStmt *flashback_tenant_stmt = NULL;
/**
* the length of database name should less than 127 bytes because of compatibility
*/
int32_t max_database_name_length = GET_MIN_CLUSTER_VERSION() < CLUSTER_CURRENT_VERSION ?
OB_MAX_DATABASE_NAME_LENGTH - 1 : OB_MAX_DATABASE_NAME_LENGTH;
if (OB_ISNULL(session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_info is null", K(ret));
} else if (T_FLASHBACK_TENANT != parser_tree.type_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(parser_tree.type_));
}
//create flashback table stmt
if (OB_SUCC(ret)) {
if (NULL == (flashback_tenant_stmt = create_stmt<ObFlashBackTenantStmt>())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to create flashback tenant stmt", K(ret));
} else {
stmt_ = flashback_tenant_stmt;
}
}
if (OB_SUCC(ret)) {
flashback_tenant_stmt->set_tenant_id(session_info_->get_effective_tenant_id());
ObString origin_tenant_name;
ParseNode *origin_tenant_node = parser_tree.children_[ORIGIN_TENANT_NODE];
if (OB_ISNULL(origin_tenant_node) || OB_UNLIKELY(T_IDENT != origin_tenant_node->type_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parse tree", K(ret));
} else if (OB_UNLIKELY(
static_cast<int32_t>(origin_tenant_node->str_len_) > max_database_name_length)) {
ret = OB_ERR_TOO_LONG_IDENT;
LOG_USER_ERROR(OB_ERR_TOO_LONG_IDENT, (int)origin_tenant_node->str_len_, origin_tenant_node->str_value_);
} else {
origin_tenant_name.assign_ptr(origin_tenant_node->str_value_,
static_cast<int32_t>(origin_tenant_node->str_len_));
flashback_tenant_stmt->set_origin_tenant_name(origin_tenant_name);
}
}
if (OB_SUCC(ret)) {
ParseNode *new_tenant_node = parser_tree.children_[NEW_TENANT_NODE];
ObString new_tenant_name;
if (NULL != new_tenant_node) {
if (OB_UNLIKELY(
static_cast<int32_t>(new_tenant_node->str_len_) > max_database_name_length)) {
ret = OB_ERR_TOO_LONG_IDENT;
LOG_USER_ERROR(OB_ERR_TOO_LONG_IDENT, (int)new_tenant_node->str_len_, new_tenant_node->str_value_);
} else {
new_tenant_name.assign_ptr(new_tenant_node->str_value_,
static_cast<int32_t>(new_tenant_node->str_len_));
flashback_tenant_stmt->set_new_tenant_name(new_tenant_name);
}
}
}
return ret;
}
} //namespace sql
} // namespace oceanbase

75
src/sql/resolver/ddl/ob_flashback_resolver.h Normal file
View File

@ -0,0 +1,75 @@
/**
* 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_FLASHBACK_RESOLVER_
#define OCEANBASE_SQL_OB_FLASHBACK_RESOLVER_
#include "sql/resolver/ddl/ob_flashback_stmt.h"
#include "sql/resolver/ddl/ob_ddl_resolver.h"
namespace oceanbase
{
namespace sql
{
class ObFlashBackTableFromRecyclebinResolver : public ObDDLResolver
{
static const int ORIGIN_TABLE_NODE = 0;
static const int NEW_TABLE_NODE = 1;
public:
explicit ObFlashBackTableFromRecyclebinResolver(ObResolverParams &params)
: ObDDLResolver(params){}
virtual ~ObFlashBackTableFromRecyclebinResolver() {}
virtual int resolve(const ParseNode &parse_tree);
private:
DISALLOW_COPY_AND_ASSIGN(ObFlashBackTableFromRecyclebinResolver);
};
class ObFlashBackIndexResolver : public ObDDLResolver
{
static const int ORIGIN_TABLE_NODE = 0;
static const int NEW_TABLE_NODE = 1;
public:
explicit ObFlashBackIndexResolver(ObResolverParams &params)
: ObDDLResolver(params){}
virtual ~ObFlashBackIndexResolver() {}
virtual int resolve(const ParseNode &parse_tree);
private:
DISALLOW_COPY_AND_ASSIGN(ObFlashBackIndexResolver);
};
class ObFlashBackDatabaseResolver : public ObDDLResolver
{
static const int ORIGIN_DB_NODE = 0;
static const int NEW_DB_NODE = 1;
public:
explicit ObFlashBackDatabaseResolver(ObResolverParams &params)
: ObDDLResolver(params){}
virtual ~ObFlashBackDatabaseResolver() {}
virtual int resolve(const ParseNode &parse_tree);
private:
DISALLOW_COPY_AND_ASSIGN(ObFlashBackDatabaseResolver);
};
class ObFlashBackTenantResolver : public ObDDLResolver
{
static const int ORIGIN_TENANT_NODE = 0;
static const int NEW_TENANT_NODE = 1;
public:
explicit ObFlashBackTenantResolver(ObResolverParams &params)
: ObDDLResolver(params){}
virtual ~ObFlashBackTenantResolver() {}
virtual int resolve(const ParseNode &parse_tree);
private:
DISALLOW_COPY_AND_ASSIGN(ObFlashBackTenantResolver);
};
} // namespace sql
} // namespace oceanbase
#endif //OCEANBASE_SQL_OB_FLASHBACK_RESOLVER_

196
src/sql/resolver/ddl/ob_flashback_stmt.h Normal file
View File

@ -0,0 +1,196 @@
/**
* 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_FLASHBACK_STMT_
#define OCEANBASE_SQL_OB_FLASHBACK_STMT_
#include "share/ob_rpc_struct.h"
#include "sql/resolver/ddl/ob_ddl_stmt.h"
#include "sql/resolver/ob_stmt_resolver.h"
namespace oceanbase
{
namespace sql
{
/**
* flashback table
*/
class ObFlashBackTableFromRecyclebinStmt : public ObDDLStmt
{
public:
ObFlashBackTableFromRecyclebinStmt() : ObDDLStmt(stmt::T_FLASHBACK_TABLE_FROM_RECYCLEBIN) {}
explicit ObFlashBackTableFromRecyclebinStmt(common::ObIAllocator *name_pool)
: ObDDLStmt(name_pool, stmt::T_FLASHBACK_TABLE_FROM_RECYCLEBIN)
{}
virtual ~ObFlashBackTableFromRecyclebinStmt() {}
const obrpc::ObFlashBackTableFromRecyclebinArg& get_flashback_table_arg() const { return flashback_table_arg_; }
inline void set_tenant_id(const uint64_t tenant_id);
uint64_t get_tenant_id() const { return flashback_table_arg_.tenant_id_; }
inline void set_origin_table_id(const uint64_t origin_table);
uint64_t get_origin_table_id() const { return flashback_table_arg_.origin_table_id_; }
common::ObString get_origin_db_name() const { return flashback_table_arg_.origin_db_name_; };
common::ObString get_origin_table_name() const { return flashback_table_arg_.origin_table_name_; };
void set_origin_table_name(const common::ObString &origin_table_name);
void set_origin_db_name(const common::ObString &origin_db_name);
void set_new_table_name(const common::ObString &new_table_name);
void set_new_db_name(const common::ObString &new_db_name);
virtual obrpc::ObDDLArg &get_ddl_arg() { return flashback_table_arg_; }
TO_STRING_KV(K_(stmt_type),K_(flashback_table_arg));
private:
obrpc::ObFlashBackTableFromRecyclebinArg flashback_table_arg_;
DISALLOW_COPY_AND_ASSIGN(ObFlashBackTableFromRecyclebinStmt);
};
inline void ObFlashBackTableFromRecyclebinStmt::set_tenant_id(const uint64_t tenant_id)
{
flashback_table_arg_.tenant_id_ = tenant_id;
}
inline void ObFlashBackTableFromRecyclebinStmt::set_origin_db_name(
const common::ObString &origin_db_name)
{
flashback_table_arg_.origin_db_name_ = origin_db_name;
}
inline void ObFlashBackTableFromRecyclebinStmt::set_origin_table_id(const uint64_t origin_table_id)
{
flashback_table_arg_.origin_table_id_ = origin_table_id;
}
inline void ObFlashBackTableFromRecyclebinStmt::set_origin_table_name(const common::ObString &origin_table_name)
{
flashback_table_arg_.origin_table_name_ = origin_table_name;
}
inline void ObFlashBackTableFromRecyclebinStmt::set_new_table_name(const common::ObString &new_table_name)
{
flashback_table_arg_.new_table_name_ = new_table_name;
}
inline void ObFlashBackTableFromRecyclebinStmt::set_new_db_name(const common::ObString &new_db_name)
{
flashback_table_arg_.new_db_name_ = new_db_name;
}
/**
* flashback index
*/
class ObFlashBackIndexStmt : public ObDDLStmt
{
public:
ObFlashBackIndexStmt() : ObDDLStmt(stmt::T_FLASHBACK_INDEX) {}
explicit ObFlashBackIndexStmt(common::ObIAllocator *name_pool)
: ObDDLStmt(name_pool, stmt::T_FLASHBACK_INDEX)
{}
virtual ~ObFlashBackIndexStmt() {}
const obrpc::ObFlashBackIndexArg& get_flashback_index_arg() const { return flashback_index_arg_; }
inline void set_tenant_id(const uint64_t tenant_id);
uint64_t get_tenant_id() const { return flashback_index_arg_.tenant_id_; }
inline void set_origin_table_id(const uint64_t origin_table_id);
uint64_t get_origin_table_id() const { return flashback_index_arg_.origin_table_id_; }
void set_origin_table_name(const common::ObString &origin_table_name);
void set_origin_db_name(const common::ObString origin_db_name);
void set_new_table_name(const common::ObString &new_table_name);
void set_new_db_name(const common::ObString &new_db_name);
virtual obrpc::ObDDLArg &get_ddl_arg() { return flashback_index_arg_; }
TO_STRING_KV(K_(stmt_type),K_(flashback_index_arg));
private:
obrpc::ObFlashBackIndexArg flashback_index_arg_;
DISALLOW_COPY_AND_ASSIGN(ObFlashBackIndexStmt);
};
inline void ObFlashBackIndexStmt::set_tenant_id(const uint64_t tenant_id)
{
flashback_index_arg_.tenant_id_ = tenant_id;
}
inline void ObFlashBackIndexStmt::set_origin_table_id(const uint64_t origin_table_id)
{
flashback_index_arg_.origin_table_id_ = origin_table_id;
}
inline void ObFlashBackIndexStmt::set_origin_table_name(const common::ObString &origin_table_name)
{
flashback_index_arg_.origin_table_name_ = origin_table_name;
}
inline void ObFlashBackIndexStmt::set_new_table_name(const common::ObString &new_table_name)
{
flashback_index_arg_.new_table_name_ = new_table_name;
}
inline void ObFlashBackIndexStmt::set_new_db_name(const common::ObString &new_db_name)
{
flashback_index_arg_.new_db_name_ = new_db_name;
}
/**
* flaskback database
*/
class ObFlashBackDatabaseStmt : public ObDDLStmt
{
public:
ObFlashBackDatabaseStmt() : ObDDLStmt(stmt::T_FLASHBACK_DATABASE) {}
explicit ObFlashBackDatabaseStmt(common::ObIAllocator *name_pool)
: ObDDLStmt(name_pool, stmt::T_FLASHBACK_DATABASE)
{}
virtual ~ObFlashBackDatabaseStmt() {}
const obrpc::ObFlashBackDatabaseArg& get_flashback_database_arg() const { return flashback_db_arg_; }
inline void set_tenant_id(const uint64_t tenant_id);
uint64_t get_tenant_id() const { return flashback_db_arg_.tenant_id_; }
const common::ObString &get_origin_db_name() const { return flashback_db_arg_.origin_db_name_; }
const common::ObString &get_new_db_name() const { return flashback_db_arg_.new_db_name_; }
void set_origin_db_name(const common::ObString origin_db_name);
void set_new_db_name(const common::ObString &new_db_name);
virtual obrpc::ObDDLArg &get_ddl_arg() { return flashback_db_arg_; }
TO_STRING_KV(K_(stmt_type),K_(flashback_db_arg));
private:
obrpc::ObFlashBackDatabaseArg flashback_db_arg_;
DISALLOW_COPY_AND_ASSIGN(ObFlashBackDatabaseStmt);
};
inline void ObFlashBackDatabaseStmt::set_tenant_id(const uint64_t tenant_id)
{
flashback_db_arg_.tenant_id_ = tenant_id;
}
inline void ObFlashBackDatabaseStmt::set_origin_db_name(const common::ObString origin_db_name)
{
flashback_db_arg_.origin_db_name_ = origin_db_name;
}
inline void ObFlashBackDatabaseStmt::set_new_db_name(const common::ObString &new_db_name)
{
flashback_db_arg_.new_db_name_ = new_db_name;
}
/**
* flaskback tenant
*/
class ObFlashBackTenantStmt : public ObDDLStmt
{
public:
ObFlashBackTenantStmt() : ObDDLStmt(stmt::T_FLASHBACK_TENANT) {}
explicit ObFlashBackTenantStmt(common::ObIAllocator *name_pool)
: ObDDLStmt(name_pool, stmt::T_FLASHBACK_TENANT)
{}
virtual ~ObFlashBackTenantStmt() {}
const obrpc::ObFlashBackTenantArg& get_flashback_tenant_arg() const { return flashback_tenant_arg_; }
inline void set_tenant_id(const uint64_t tenant_id);
virtual obrpc::ObDDLArg &get_ddl_arg() { return flashback_tenant_arg_; }
uint64_t get_tenant_id() const { return flashback_tenant_arg_.tenant_id_; }
void set_origin_tenant_name(const common::ObString origin_tenant_name);
void set_new_tenant_name(const common::ObString &new_tenant_name);
TO_STRING_KV(K_(stmt_type),K_(flashback_tenant_arg));
private:
obrpc::ObFlashBackTenantArg flashback_tenant_arg_;
DISALLOW_COPY_AND_ASSIGN(ObFlashBackTenantStmt);
};
inline void ObFlashBackTenantStmt::set_tenant_id(const uint64_t tenant_id)
{
flashback_tenant_arg_.tenant_id_ = tenant_id;
}
inline void ObFlashBackTenantStmt::set_origin_tenant_name(const common::ObString origin_tenant_name)
{
flashback_tenant_arg_.origin_tenant_name_ = origin_tenant_name;
}
inline void ObFlashBackTenantStmt::set_new_tenant_name(const common::ObString &new_tenant_name)
{
flashback_tenant_arg_.new_tenant_name_ = new_tenant_name;
}
} // namespace sql
} // namespace oceanbase
#endif //OCEANBASE_SQL_OB_RENAME_TABLE_STMT_