hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 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_

17
src/sql/resolver/ob_resolver.cpp
View File

@ -51,6 +51,7 @@
#include "sql/resolver/ddl/ob_alter_outline_resolver.h"
#include "sql/resolver/ddl/ob_drop_outline_resolver.h"
#include "sql/resolver/ddl/ob_optimize_resolver.h"
#include "sql/resolver/ddl/ob_flashback_resolver.h"
#include "sql/resolver/ddl/ob_purge_resolver.h"
#include "sql/resolver/ddl/ob_alter_baseline_resolver.h"
#include "sql/resolver/ddl/ob_purge_resolver.h"
@ -481,6 +482,22 @@ int ObResolver::resolve(IsPrepared if_prepared, const ParseNode& parse_tree, ObS
REGISTER_STMT_RESOLVER(TruncateTable);
break;
}
case T_FLASHBACK_TABLE_FROM_RECYCLEBIN: {
REGISTER_STMT_RESOLVER(FlashBackTableFromRecyclebin);
break;
}
case T_FLASHBACK_INDEX: {
REGISTER_STMT_RESOLVER(FlashBackIndex);
break;
}
case T_FLASHBACK_DATABASE: {
REGISTER_STMT_RESOLVER(FlashBackDatabase);
break;
}
case T_FLASHBACK_TENANT: {
REGISTER_STMT_RESOLVER(FlashBackTenant);
break;
}
case T_PURGE_TABLE: {
REGISTER_STMT_RESOLVER(PurgeTable);
break;

5
src/sql/resolver/ob_resolver_utils.cpp
View File

@ -348,6 +348,11 @@ stmt::StmtType ObResolverUtils::get_stmt_type_by_item_type(const ObItemType item
// index
SET_STMT_TYPE(T_CREATE_INDEX);
SET_STMT_TYPE(T_DROP_INDEX);
// flashback
SET_STMT_TYPE(T_FLASHBACK_TENANT);
SET_STMT_TYPE(T_FLASHBACK_DATABASE);
SET_STMT_TYPE(T_FLASHBACK_TABLE_FROM_RECYCLEBIN);
SET_STMT_TYPE(T_FLASHBACK_INDEX);
// purge
SET_STMT_TYPE(T_PURGE_RECYCLEBIN);
SET_STMT_TYPE(T_PURGE_TENANT);

10
src/sql/resolver/ob_stmt.h
View File

@ -278,6 +278,11 @@ public:
// index
|| stmt_type == stmt::T_CREATE_INDEX ||
stmt_type == stmt::T_DROP_INDEX
// flashback
|| stmt_type == stmt::T_FLASHBACK_TENANT
|| stmt_type == stmt::T_FLASHBACK_DATABASE
|| stmt_type == stmt::T_FLASHBACK_TABLE_FROM_RECYCLEBIN
|| stmt_type == stmt::T_FLASHBACK_INDEX
// purge
|| stmt_type == stmt::T_PURGE_RECYCLEBIN || stmt_type == stmt::T_PURGE_TENANT ||
stmt_type == stmt::T_PURGE_DATABASE || stmt_type == stmt::T_PURGE_TABLE ||
@ -351,6 +356,11 @@ public:
|| stmt_type == stmt::T_DROP_VIEW
// index
|| stmt_type == stmt::T_DROP_INDEX
// flashback
|| stmt_type == stmt::T_FLASHBACK_TENANT
|| stmt_type == stmt::T_FLASHBACK_DATABASE
|| stmt_type == stmt::T_FLASHBACK_TABLE_FROM_RECYCLEBIN
|| stmt_type == stmt::T_FLASHBACK_INDEX
// purge
|| stmt_type == stmt::T_PURGE_RECYCLEBIN || stmt_type == stmt::T_PURGE_TENANT ||
stmt_type == stmt::T_PURGE_DATABASE || stmt_type == stmt::T_PURGE_TABLE ||

4
src/sql/resolver/ob_stmt_type.h
View File

@ -139,6 +139,10 @@ OB_STMT_TYPE_DEF(T_DROP_OUTLINE, no_priv_needed, 126)
OB_STMT_TYPE_DEF(T_ALTER_BASELINE, get_sys_tenant_alter_system_priv, 127)
OB_STMT_TYPE_DEF(T_LOAD_BASELINE, get_sys_tenant_alter_system_priv, 128)
OB_STMT_TYPE_DEF(T_SWITCH_RS_ROLE, get_sys_tenant_alter_system_priv, 129)
OB_STMT_TYPE_DEF(T_FLASHBACK_TENANT, get_flashback_tenant_stmt_need_privs, 130)
OB_STMT_TYPE_DEF(T_FLASHBACK_DATABASE, get_flashback_database_stmt_need_privs, 131)
OB_STMT_TYPE_DEF(T_FLASHBACK_TABLE_FROM_RECYCLEBIN, get_flashback_table_stmt_need_privs, 132)
OB_STMT_TYPE_DEF(T_FLASHBACK_INDEX, get_flashback_index_stmt_need_privs, 133)
OB_STMT_TYPE_DEF(T_PURGE_RECYCLEBIN, get_purge_recyclebin_stmt_need_privs, 134)
OB_STMT_TYPE_DEF(T_PURGE_TENANT, get_purge_tenant_stmt_need_privs, 135)
OB_STMT_TYPE_DEF(T_PURGE_DATABASE, get_purge_database_stmt_need_privs, 136)