406 lines
16 KiB
C++
406 lines
16 KiB
C++
/**
|
|
* 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/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 回收站中的表
|
|
// 复用一个以前 unused 的 origin_db_name, 指定需要 flashback 的表是从哪个库删除的
|
|
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;
|
|
}
|
|
|
|
int ObFlashBackTableToScnResolver::resolve(const ParseNode &parse_tree)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObFlashBackTableToScnStmt *stmt = nullptr;
|
|
if (OB_ISNULL(session_info_) ||
|
|
(T_FLASHBACK_TABLE_TO_TIMESTAMP != parse_tree.type_ && T_FLASHBACK_TABLE_TO_SCN != parse_tree.type_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("invalid argument", K(ret));
|
|
} else if (nullptr == (stmt = create_stmt<ObFlashBackTableToScnStmt>())) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_ERROR("failed to create flsahbck stmt", K(ret));
|
|
} else {
|
|
uint64_t tenant_id = session_info_->get_effective_tenant_id();
|
|
stmt->set_tenant_id(tenant_id);
|
|
obrpc::ObFlashBackTableToScnArg &arg = stmt->flashback_table_to_scn_arg_;
|
|
ParseNode *table_node = parse_tree.children_[TABLE_NODES];
|
|
ObString db_name;
|
|
ObString table_name;
|
|
obrpc::ObTableItem table_item;
|
|
if (nullptr == table_node) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("table_node is null", K(ret));
|
|
} else {
|
|
int64_t table_num = parse_tree.children_[TABLE_NODES]->num_child_;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < table_num; i++) {
|
|
ParseNode *node = parse_tree.children_[TABLE_NODES]->children_[i];
|
|
if (nullptr == node) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("table node is null", K(ret));
|
|
} else if (OB_FAIL(resolve_table_relation_node(node, table_name, db_name))) {
|
|
LOG_WARN("failed to resolve table relaiton node", K(ret));
|
|
} else if (OB_FAIL(session_info_->get_name_case_mode(table_item.mode_))) {
|
|
LOG_WARN("failed to get name case mode", K(ret));
|
|
} else {
|
|
const share::schema::ObTableSchema *table_schema = NULL;
|
|
table_item.database_name_ = db_name;
|
|
table_item.table_name_ = table_name;
|
|
OZ (arg.tables_.push_back(table_item));
|
|
OZ (schema_checker_->get_table_schema(tenant_id,
|
|
db_name,
|
|
table_name,
|
|
false, /*is_index*/
|
|
table_schema));
|
|
if (OB_SUCC(ret) && table_schema == NULL) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("table_shema is null", K(ret), K(db_name), K(table_name));
|
|
}
|
|
if (OB_SUCC(ret) && ObSchemaChecker::is_ora_priv_check()) {
|
|
OZ (schema_checker_->check_ora_ddl_priv(
|
|
tenant_id,
|
|
session_info_->get_priv_user_id(),
|
|
db_name,
|
|
table_schema->get_table_id(),
|
|
static_cast<uint64_t>(share::schema::ObObjectType::TABLE),
|
|
stmt::T_FLASHBACK_TABLE_TO_SCN,
|
|
session_info_->get_enable_role_array()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
ParseNode *time_node = parse_tree.children_[TIME_NODE];
|
|
ObRawExpr *expr = nullptr;
|
|
if (nullptr == time_node) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("time_node is null", K(ret));
|
|
} else if (OB_FAIL(ObResolverUtils::resolve_const_expr(
|
|
params_, *time_node, expr, nullptr))) {
|
|
LOG_WARN("resolve sql expr failed");
|
|
} else if (OB_ISNULL(expr)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("expr is null", K(ret));
|
|
} else {
|
|
stmt->set_time_expr(expr);
|
|
if (T_FLASHBACK_TABLE_TO_SCN == parse_tree.type_) {
|
|
stmt->set_time_type(ObFlashBackTableToScnStmt::TIME_SCN);
|
|
} else if (T_FLASHBACK_TABLE_TO_TIMESTAMP == parse_tree.type_) {
|
|
stmt->set_time_type(ObFlashBackTableToScnStmt::TIME_TIMESTAMP);
|
|
} else {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected error", K(ret));
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
int64_t start_time = session_info_->get_query_start_time();
|
|
int64_t query_timeout = 0;
|
|
// get_query_timeout里面肯定返回OB_SUCCESS，所以后面代码不需要在判断
|
|
// 返回值了
|
|
OZ(session_info_->get_query_timeout(query_timeout));
|
|
stmt->set_query_end_time(start_time + query_timeout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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(),
|
|
OB_RECYCLEBIN_SCHEMA_ID,
|
|
origin_table_name,
|
|
true, /*is_index*/
|
|
false, /*cte_table_fisrt*/
|
|
false/*is_hidden*/,
|
|
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;
|
|
int32_t max_database_name_length = 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;
|
|
int32_t max_database_name_length = 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 common
|
|
}
|