hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
cea7de1475674a82a317f7f550d141c6096d487e
oceanbase/src/sql/resolver/ob_schema_checker.cpp
oceanbase-admin cea7de1475 init push
2021-05-31 22:56:52 +08:00

1805 lines
66 KiB
C++
Raw Blame History

/**
* 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_schema_checker.h"
#include "lib/string/ob_string.h"
#include "lib/thread_local/ob_tsi_factory.h"
#include "lib/oblog/ob_log.h"
#include "share/schema/ob_schema_getter_guard.h"
#include "share/schema/ob_column_schema.h"
#include "share/schema/ob_table_schema.h"
#include "share/schema/ob_schema_struct.h"
#include "share/schema/ob_schema_mgr.h"
#include "share/schema/ob_udf.h"
#include "share/schema/ob_synonym_mgr.h"
#include "sql/privilege_check/ob_ora_priv_check.h"
#include "sql/ob_sql_mock_schema_utils.h"
#include "sql/ob_sql_context.h"
#include "sql/resolver/ob_resolver_define.h"
#include "observer/virtual_table/ob_table_columns.h"
#include "common/ob_smart_call.h"
using namespace oceanbase::sql;
using namespace oceanbase::common;
using namespace oceanbase::share::schema;
using oceanbase::share::schema::ObColumnSchemaV2;
using oceanbase::share::schema::ObDatabaseSchema;
using oceanbase::share::schema::ObTableSchema;
using oceanbase::share::schema::ObTenantSchema;
namespace oceanbase {
namespace sql {
ObSchemaChecker::ObSchemaChecker() : is_inited_(false), schema_mgr_(NULL), sql_schema_mgr_(NULL), flag_(0)
{}
ObSchemaChecker::~ObSchemaChecker()
{
schema_mgr_ = NULL;
sql_schema_mgr_ = NULL;
}
int ObSchemaChecker::init(ObSchemaGetterGuard& schema_mgr, uint64_t session_id)
{
int ret = OB_SUCCESS;
if (is_inited_) {
ret = OB_INIT_TWICE;
LOG_WARN("inited twice", K(ret));
} else {
schema_mgr_ = &schema_mgr;
is_inited_ = true;
flag_ = 0;
schema_mgr.set_session_id(session_id);
if (OB_INVALID_ID != session_id) {
LOG_DEBUG("ObSchemaChecker init with valid session id", K(session_id));
}
}
return ret;
}
int ObSchemaChecker::init(ObSqlSchemaGuard& sql_schema_mgr, uint64_t session_id)
{
int ret = OB_SUCCESS;
OV(OB_NOT_NULL(sql_schema_mgr.get_schema_guard()));
OZ(init(*sql_schema_mgr.get_schema_guard(), session_id));
OX(sql_schema_mgr_ = &sql_schema_mgr);
return ret;
}
int ObSchemaChecker::set_lbca_op()
{
int ret = OB_SUCCESS;
flag_ = LBCA_OP_FLAG;
return ret;
}
bool ObSchemaChecker::is_lbca_op()
{
return flag_ == LBCA_OP_FLAG;
}
int ObSchemaChecker::check_ora_priv(const uint64_t tenant_id, const uint64_t uid,
const share::schema::ObStmtOraNeedPrivs& stmt_need_privs, const ObIArray<uint64_t>& role_id_array) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_FAIL(schema_mgr_->check_ora_priv(tenant_id, uid, stmt_need_privs, role_id_array))) {
LOG_WARN("failed to check_priv", K(tenant_id), K(uid), K(stmt_need_privs), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::check_priv(
const share::schema::ObSessionPrivInfo& session_priv, const share::schema::ObStmtNeedPrivs& stmt_need_privs) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(!session_priv.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("session_priv is invalid", K(session_priv), K(ret));
} else if (OB_FAIL(schema_mgr_->check_priv(session_priv, stmt_need_privs))) {
LOG_WARN("failed to check_priv", K(session_priv), K(stmt_need_privs), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::check_priv_or(
const share::schema::ObSessionPrivInfo& session_priv, const share::schema::ObStmtNeedPrivs& stmt_need_privs)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(!session_priv.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("session_priv is invalid", K(session_priv), K(ret));
} else if (OB_FAIL(schema_mgr_->check_priv_or(session_priv, stmt_need_privs))) {
LOG_WARN("failed to check_priv_or", K(session_priv), K(stmt_need_privs), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::check_db_access(share::schema::ObSessionPrivInfo& s_priv, const ObString& database_name) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(!s_priv.is_valid() || database_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(s_priv), K(database_name), K(ret));
} else if (OB_FAIL(schema_mgr_->check_db_access(s_priv, database_name))) {
LOG_WARN("failed to check_db_access", K(s_priv), K(database_name), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::check_table_show(
const share::schema::ObSessionPrivInfo& s_priv, const ObString& db, const ObString& table, bool& allow_show) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(!s_priv.is_valid() || db.empty() || table.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(s_priv), K(db), K(table), K(ret));
} else if (OB_FAIL(schema_mgr_->check_table_show(s_priv, db, table, allow_show))) {
LOG_WARN("failed to check_table_show", K(s_priv), K(db), K(table), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::check_column_exists(const uint64_t table_id, const ObString& column_name, bool& is_exist)
{
int ret = OB_SUCCESS;
is_exist = false;
const ObColumnSchemaV2* column_schema = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id || column_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(column_name), K(ret));
} else {
if (share::is_oracle_mode() && 0 == column_name.case_compare(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME)) {
const ObTableSchema* table_schema = NULL;
if (OB_FAIL(get_table_schema_inner(table_id, table_schema))) {
LOG_WARN("failed to get table schema", K(ret));
} else if (OB_ISNULL(table_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null table schema", K(ret));
} else if (OB_FAIL(ObSQLMockSchemaUtils::add_mock_table(table_id))) {
LOG_WARN("failed to add mock table id", K(ret));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(get_column_schema_inner(table_id, column_name, column_schema))) {
LOG_WARN("get column schema failed", K(table_id), K(column_name), K(ret));
}
if (NULL == column_schema) {
for (int64_t i = 0; OB_SUCC(ret) && i < tmp_cte_schemas_.count(); ++i) {
if (tmp_cte_schemas_.at(i)->get_table_id() == table_id) {
column_schema = tmp_cte_schemas_.at(i)->get_column_schema(column_name);
break;
}
}
}
if (NULL == column_schema) {
is_exist = false;
} else {
is_exist = true;
}
}
return ret;
}
int ObSchemaChecker::check_column_exists(uint64_t table_id, uint64_t column_id, bool& is_exist)
{
int ret = OB_SUCCESS;
is_exist = false;
const ObColumnSchemaV2* column_schema = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id || OB_INVALID_ID == column_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(column_id), K(ret));
} else {
if (OB_FAIL(get_column_schema_inner(table_id, column_id, column_schema))) {
LOG_WARN("get column schema failed", K(table_id), K(column_id), K(ret));
}
if (NULL == column_schema) {
for (int64_t i = 0; OB_SUCC(ret) && i < tmp_cte_schemas_.count(); ++i) {
if (tmp_cte_schemas_.at(i)->get_table_id() == table_id) {
column_schema = tmp_cte_schemas_.at(i)->get_column_schema(column_id);
break;
}
}
}
if (NULL == column_schema) {
is_exist = false;
} else {
is_exist = true;
}
}
return ret;
}
int ObSchemaChecker::check_routine_show(
const share::schema::ObSessionPrivInfo& s_priv, const ObString& db, const ObString& routine, bool& allow_show) const
{
int ret = OB_SUCCESS;
allow_show = true;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(!s_priv.is_valid() || db.empty() || routine.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(s_priv), K(db), K(routine), K(ret));
// } else if (OB_FAIL(schema_mgr_->check_routine_show(s_priv, db, routine, allow_show))) { //TODO:
// LOG_WARN("failed to check_table_show", K(s_priv), K(db), K(routine), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::check_table_or_index_exists(
const uint64_t tenant_id, const uint64_t database_id, const ObString& table_name, bool& is_exist)
{
int ret = OB_SUCCESS;
bool is_index_table = false;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == database_id || table_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_id), K(table_name), K(ret));
} else if (OB_FAIL(check_table_exists(tenant_id, database_id, table_name, is_index_table, is_exist))) {
LOG_WARN("check table exist failed", K(tenant_id), K(database_id), K(table_name), K(ret));
} else if (!is_exist) {
is_index_table = true;
if (OB_FAIL(check_table_exists(tenant_id, database_id, table_name, is_index_table, is_exist))) {
LOG_WARN("check index exist failed", K(tenant_id), K(database_id), K(table_name), K(ret));
}
}
return ret;
}
int ObSchemaChecker::check_table_exists(const uint64_t tenant_id, const uint64_t database_id,
const ObString& table_name, const bool is_index_table, bool& is_exist)
{
int ret = OB_SUCCESS;
is_exist = false;
uint64_t table_id = OB_INVALID_ID;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == database_id || table_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_id), K(table_name), K(ret));
} else {
if (OB_FAIL(schema_mgr_->get_table_id(
tenant_id, database_id, table_name, is_index_table, ObSchemaGetterGuard::ALL_TYPES, table_id))) {
LOG_WARN("get table id failed", K(ret), K(tenant_id), K(database_id), K(table_name), K(is_index_table));
} else {
is_exist = (OB_INVALID_ID != table_id);
if (is_exist == false) {
bool exist = false;
if (OB_FAIL(find_fake_cte_schema(table_name, exist))) {
LOG_WARN("can not find the table", K(ret), K(tenant_id), K(database_id), K(table_name), K(is_index_table));
} else {
is_exist = exist;
}
}
}
}
return ret;
}
int ObSchemaChecker::check_table_exists(const uint64_t tenant_id, const ObString& database_name,
const ObString& table_name, const bool is_index_table, bool& is_exist)
{
int ret = OB_SUCCESS;
is_exist = false;
uint64_t table_id = OB_INVALID_ID;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || database_name.empty() || table_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_name), K(table_name), K(ret));
} else {
if (OB_FAIL(schema_mgr_->get_table_id(
tenant_id, database_name, table_name, is_index_table, ObSchemaGetterGuard::ALL_TYPES, table_id))) {
LOG_WARN("fail to check table exist", K(tenant_id), K(database_name), K(table_name), K(is_index_table), K(ret));
} else {
is_exist = (OB_INVALID_ID != table_id);
}
}
return ret;
}
int ObSchemaChecker::get_database_id(const uint64_t tenant_id, const ObString& database_name, uint64_t& database_id)
{
int ret = OB_SUCCESS;
database_id = OB_INVALID_ID;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || database_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_name), K(ret));
} else {
if (OB_FAIL(schema_mgr_->get_database_id(tenant_id, database_name, database_id))) {
LOG_WARN("fail to get database id", K(tenant_id), K(database_name), K(database_id), K(ret));
} else if (OB_INVALID_ID == database_id) {
ret = OB_ERR_BAD_DATABASE;
LOG_WARN("database is not exist", K(tenant_id), K(database_name), K(ret));
}
}
return ret;
}
int ObSchemaChecker::get_column_schema(
const uint64_t table_id, const ObString& column_name, const ObColumnSchemaV2*& column_schema, bool get_hidden)
{
int ret = OB_SUCCESS;
column_schema = NULL;
const ObColumnSchemaV2* column = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id || column_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(column_name), K(ret));
} else {
if (OB_FAIL(get_column_schema_inner(table_id, column_name, column))) {
LOG_WARN("get column schema failed", K(table_id), K(column_name), K(ret));
} else if (NULL == column) {
for (int64_t i = 0; i < tmp_cte_schemas_.count(); i++) {
if (tmp_cte_schemas_.at(i)->get_table_id() == table_id) {
column = tmp_cte_schemas_.at(i)->get_column_schema(column_name);
break;
}
}
if (NULL == column) {
ret = OB_ERR_BAD_FIELD_ERROR;
LOG_WARN("column is not exist", K(table_id), K(column_name), K(ret));
} else {
column_schema = column;
LOG_DEBUG("find a cte fake column", K(column_name));
}
} else if (!get_hidden && column->is_hidden()) {
ret = OB_ERR_BAD_FIELD_ERROR;
LOG_INFO("do not get hidden column", K(table_id), K(column_name), K(ret));
} else {
column_schema = column;
}
}
return ret;
}
int ObSchemaChecker::get_column_schema(
const uint64_t table_id, const uint64_t column_id, const ObColumnSchemaV2*& column_schema, const bool get_hidden)
{
int ret = OB_SUCCESS;
column_schema = NULL;
const ObColumnSchemaV2* column = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id || OB_INVALID_ID == column_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(column_id), K(ret));
} else {
if (OB_HIDDEN_LOGICAL_ROWID_COLUMN_ID == column_id) {
if (OB_FAIL(ObSQLMockSchemaUtils::add_mock_table(table_id))) {
LOG_WARN("failed to add mock table", K(ret));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(get_column_schema_inner(table_id, column_id, column))) {
LOG_WARN("get column schema failed", K(table_id), K(column_id), K(ret));
} else if (NULL == column) {
ret = OB_ERR_BAD_FIELD_ERROR;
LOG_WARN("column is not exist", K(table_id), K(column_id), K(ret));
} else if (!get_hidden && column->is_hidden()) {
ret = OB_ERR_BAD_FIELD_ERROR;
LOG_INFO("do not get hidden column", K(table_id), K(column_id), K(ret));
} else {
column_schema = column;
}
}
return ret;
}
int ObSchemaChecker::get_user_id(
const uint64_t tenant_id, const ObString& user_name, const ObString& host_name, uint64_t& user_id)
{
int ret = OB_SUCCESS;
user_id = OB_INVALID_ID;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || user_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(user_name), K(ret));
} else if (OB_FAIL(schema_mgr_->get_user_id(tenant_id, user_name, host_name, user_id))) {
LOG_WARN("get user id failed", K(tenant_id), K(user_name), K(host_name), K(ret));
} else if (OB_INVALID_ID == user_id) {
ret = OB_USER_NOT_EXIST;
LOG_WARN("user is not exist", K(tenant_id), K(user_name), K(host_name), K(ret));
}
return ret;
}
int ObSchemaChecker::get_user_info(const uint64_t user_id, const ObUserInfo*& user_info)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_INVALID_ID == user_id) {
ret = OB_USER_NOT_EXIST;
LOG_WARN("user is not exist", K(user_id), K(ret));
} else if (OB_FAIL(schema_mgr_->get_user_info(user_id, user_info))) {
LOG_WARN("user is not exist", K(user_id), K(ret));
} else if (NULL == user_info) {
ret = OB_USER_NOT_EXIST;
LOG_WARN("user is not exist", K(user_id), K(ret));
}
return ret;
}
int ObSchemaChecker::get_user_info(
const uint64_t tenant_id, const ObString& user_name, const ObString& host_name, const ObUserInfo*& user_info)
{
int ret = OB_SUCCESS;
uint64_t user_id = OB_INVALID_ID;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || user_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(user_name), K(ret));
} else if (OB_FAIL(schema_mgr_->get_user_id(tenant_id, user_name, host_name, user_id))) {
LOG_WARN("get user id failed", K(tenant_id), K(user_name), K(host_name), K(ret));
} else if (OB_FAIL(get_user_info(user_id, user_info))) {
LOG_WARN("user is not exist", K(user_id), K(user_name), K(host_name), K(ret));
} else if (NULL == user_info) {
ret = OB_USER_NOT_EXIST;
LOG_WARN("user is not exist", K(tenant_id), K(user_name), K(host_name), K(ret));
}
return ret;
}
int ObSchemaChecker::check_table_exists_with_synonym(const uint64_t tenant_id, const ObString& tbl_db_name,
const ObString& tbl_name, bool is_index_table, bool& has_synonym, bool& table_exist)
{
int ret = OB_SUCCESS;
uint64_t tbl_db_id = OB_INVALID_ID;
uint64_t obj_db_id = OB_INVALID_ID;
ObSEArray<uint64_t, 8> syn_id_arr;
ObString obj_name;
table_exist = false;
has_synonym = false;
if (OB_FAIL(check_table_exists(tenant_id, tbl_db_name, tbl_name, is_index_table, table_exist))) {
LOG_WARN("check_table_exists failed", K(tenant_id), K(tbl_db_name), K(tbl_name), K(is_index_table));
} else if (false == table_exist) {
// try again with synonym
if (OB_FAIL(get_database_id(tenant_id, tbl_db_name, tbl_db_id))) {
LOG_WARN("get database id failed", K(ret), K(tenant_id), K(tbl_db_name), K(tbl_name));
} else if (OB_FAIL(get_obj_info_recursively_with_synonym(
tenant_id, tbl_db_id, tbl_name, obj_db_id, obj_name, syn_id_arr))) {
if (OB_SYNONYM_NOT_EXIST == ret) {
table_exist = false;
ret = OB_SUCCESS;
LOG_DEBUG("obj is not a synonym", K(tbl_name), K(ret));
} else {
LOG_WARN("get real obj represented by synonym failed",
K(ret),
K(tenant_id),
K(tbl_db_name),
K(tbl_db_id),
K(tbl_name));
}
} else {
has_synonym = true;
const ObDatabaseSchema* db_schema = NULL;
if (OB_FAIL(check_table_exists(tenant_id, obj_db_id, obj_name, is_index_table, table_exist))) {
LOG_WARN("get_table_schema failed", K(ret), K(tenant_id), K(tbl_db_name), K(tbl_db_id), K(tbl_name));
} else if (false == table_exist) {
ret = OB_ERR_SYNONYM_TRANSLATION_INVALID;
LOG_WARN("object is synonym, but real object not exist",
K(ret),
K(tenant_id),
K(tbl_db_name),
K(tbl_name),
K(obj_name));
LOG_USER_ERROR(OB_ERR_SYNONYM_TRANSLATION_INVALID, to_cstring(tbl_name));
}
}
} else {
// table found. do nothing
}
return ret;
}
int ObSchemaChecker::get_table_schema_with_synonym(const uint64_t tenant_id, const ObString& tbl_db_name,
const ObString& tbl_name, bool is_index_table, bool& has_synonym, ObString& new_db_name, ObString& new_tbl_name,
const share::schema::ObTableSchema*& tbl_schema)
{
int ret = OB_SUCCESS;
uint64_t tbl_db_id = OB_INVALID_ID;
uint64_t obj_db_id = OB_INVALID_ID;
ObString obj_name;
bool syn_exist = false;
new_db_name.reset();
new_tbl_name.reset();
has_synonym = false;
tbl_schema = NULL;
ObSEArray<uint64_t, 8> syn_id_arr;
if (OB_FAIL(get_table_schema(tenant_id, tbl_db_name, tbl_name, is_index_table, tbl_schema))) {
if (OB_TABLE_NOT_EXIST == ret) {
// try with synonym
if (OB_FAIL(get_database_id(tenant_id, tbl_db_name, tbl_db_id))) {
LOG_WARN("get database id failed", K(ret), K(tenant_id), K(tbl_db_name));
} else if (OB_FAIL(get_obj_info_recursively_with_synonym(
tenant_id, tbl_db_id, tbl_name, obj_db_id, obj_name, syn_id_arr))) {
if (OB_SYNONYM_NOT_EXIST == ret) {
ret = OB_TABLE_NOT_EXIST;
LOG_DEBUG("obj is not a synonym", K(tbl_name), K(ret));
} else {
LOG_WARN("get real obj represented by synonym failed",
K(ret),
K(tenant_id),
K(tbl_db_name),
K(tbl_db_id),
K(tbl_name));
}
} else {
const ObDatabaseSchema* db_schema = NULL;
has_synonym = true;
if (OB_FAIL(schema_mgr_->get_table_schema(tenant_id, obj_db_id, obj_name, is_index_table, tbl_schema))) {
LOG_WARN("get_table_schema failed", K(ret), K(tenant_id), K(obj_db_id), K(tbl_db_id), K(tbl_name));
} else if (OB_ISNULL(tbl_schema)) {
ret = OB_ERR_SYNONYM_TRANSLATION_INVALID;
LOG_WARN("object is synonym, but real object not exist",
K(ret),
K(tenant_id),
K(tbl_db_name),
K(tbl_name),
K(obj_name));
LOG_USER_ERROR(OB_ERR_SYNONYM_TRANSLATION_INVALID, to_cstring(tbl_name));
} else if (OB_FAIL(get_database_schema(tenant_id, obj_db_id, db_schema))) {
LOG_WARN("get database schema failed", K(ret), K(tenant_id), K(obj_db_id));
} else if (OB_ISNULL(db_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get database schema failed", K(ret), K(tenant_id), K(obj_db_id));
} else {
new_db_name = db_schema->get_database_name();
new_tbl_name = obj_name;
}
}
} else {
LOG_WARN("get_table_schema failed", K(ret), K(tenant_id), K(tbl_db_name), K(tbl_db_id), K(tbl_name));
}
} else {
has_synonym = false;
}
return ret;
}
int ObSchemaChecker::get_simple_table_schema(const uint64_t tenant_id, const uint64_t& db_id,
const ObString& table_name, const bool is_index_table, const ObSimpleTableSchemaV2*& simple_table_schema)
{
int ret = OB_SUCCESS;
simple_table_schema = NULL;
const ObSimpleTableSchemaV2* table = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || db_id == OB_INVALID_ID || table_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(db_id), K(table_name), K(ret));
} else if (OB_FAIL(schema_mgr_->get_simple_table_schema(tenant_id, db_id, table_name, is_index_table, table))) {
LOG_WARN("get table schema failed", K(tenant_id), K(db_id), K(table_name), K(ret));
} else if (NULL == table) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("table is not exist", K(tenant_id), K(db_id), K(table_name), K(ret));
} else {
simple_table_schema = table;
}
return ret;
}
int ObSchemaChecker::get_table_schema(const uint64_t tenant_id, const ObString& database_name,
const ObString& table_name, const bool is_index_table, const ObTableSchema*& table_schema)
{
int ret = OB_SUCCESS;
table_schema = NULL;
const ObTableSchema* table = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || database_name.empty() || table_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_name), K(table_name), K(ret));
} else if (OB_FAIL(schema_mgr_->get_table_schema(tenant_id, database_name, table_name, is_index_table, table))) {
LOG_WARN("get table schema failed", K(tenant_id), K(database_name), K(table_name), K(ret));
} else if (NULL == table) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("table is not exist", K(tenant_id), K(database_name), K(table_name), K(ret));
} else if (table->is_dropped_schema() || (false == table->is_tmp_table() && 0 != table->get_session_id() &&
OB_INVALID_ID != schema_mgr_->get_session_id())) {
ret = OB_TABLE_NOT_EXIST;
LOG_USER_ERROR(OB_TABLE_NOT_EXIST, to_cstring(database_name), to_cstring(table_name));
} else {
table_schema = table;
}
return ret;
}
// Attention: only used in SQL Layer.
int ObSchemaChecker::get_table_schema(const uint64_t tenant_id, const uint64_t database_id, const ObString& table_name,
const bool is_index_table, const bool cte_table_fisrt, const ObTableSchema*& table_schema)
{
int ret = OB_SUCCESS;
table_schema = NULL;
const ObTableSchema* table = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == database_id || table_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_id), K(table_name), K(ret));
ret = OB_INVALID_ARGUMENT;
} else if (OB_FAIL(schema_mgr_->get_table_schema(tenant_id, database_id, table_name, is_index_table, table))) {
LOG_WARN("get table schema failed", K(tenant_id), K(database_id), K(table_name), K(is_index_table), K(ret));
} else {
// If CTE table has same name with a basic table, cte table has high priority.
if (cte_table_fisrt) {
for (int64_t i = 0; i < tmp_cte_schemas_.count(); i++) {
if (tmp_cte_schemas_.at(i)->get_table_name_str() == table_name) {
table = tmp_cte_schemas_.at(i);
break;
}
}
}
if (NULL == table) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("table is not exist", K(tenant_id), K(database_id), K(table_name), K(ret));
} else if (table->is_dropped_schema() || (false == table->is_tmp_table() && 0 != table->get_session_id() &&
OB_INVALID_ID != schema_mgr_->get_session_id() &&
table->get_session_id() != schema_mgr_->get_session_id())) {
const ObDatabaseSchema* db_schema = NULL;
if (OB_FAIL(schema_mgr_->get_database_schema(tenant_id, database_id, db_schema))) {
LOG_WARN("get database schema failed", K(tenant_id), K(database_id), K(ret));
} else if (NULL == db_schema) {
ret = OB_ERR_BAD_DATABASE;
LOG_WARN("fail to get database schema", K(tenant_id), K(database_id), K(ret));
} else {
ret = OB_TABLE_NOT_EXIST;
LOG_USER_ERROR(OB_TABLE_NOT_EXIST, db_schema->get_database_name(), to_cstring(table_name));
}
} else {
table_schema = table;
}
}
return ret;
}
// Attention: only used in SQL Layer.
int ObSchemaChecker::get_table_schema(const uint64_t table_id, const ObTableSchema*& table_schema) const
{
int ret = OB_SUCCESS;
table_schema = NULL;
const ObTableSchema* table = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(ret));
} else if (OB_FAIL(get_table_schema_inner(table_id, table))) {
LOG_WARN("get table schema failed", K(table_id), K(ret));
} else if (NULL == table) {
// maybe schema of cte table.
for (int64_t i = 0; i < tmp_cte_schemas_.count(); i++) {
if (tmp_cte_schemas_.at(i)->get_table_id() == table_id) {
table = tmp_cte_schemas_.at(i);
break;
}
}
if (NULL == table) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("table is not exist", K(table_id));
} else {
table_schema = table;
}
} else if (table->is_dropped_schema()) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("table is not exist", K(table_id));
} else {
table_schema = table;
}
return ret;
}
int ObSchemaChecker::get_link_table_schema(const uint64_t dblink_id, const ObString& database_name,
const ObString& table_name, const ObTableSchema*& table_schema)
{
int ret = OB_SUCCESS;
OV(OB_NOT_NULL(sql_schema_mgr_));
OZ(sql_schema_mgr_->get_table_schema(dblink_id, database_name, table_name, table_schema),
dblink_id,
database_name,
table_name);
return ret;
}
int ObSchemaChecker::check_if_partition_key(uint64_t table_id, uint64_t column_id, bool& is_part_key) const
{
int ret = OB_SUCCESS;
is_part_key = false;
const ObTableSchema* tbl_schema = NULL;
if (OB_FAIL(get_table_schema(table_id, tbl_schema))) {
LOG_WARN("get table schema failed", K(ret), K(table_id));
} else if (tbl_schema->is_partitioned_table()) {
if (OB_FAIL(tbl_schema->get_partition_key_info().is_rowkey_column(column_id, is_part_key))) {
LOG_WARN("check if the column_id is partition key failed", K(ret), K(table_id), K(column_id));
} else if (!is_part_key && PARTITION_LEVEL_TWO == tbl_schema->get_part_level()) {
if (OB_FAIL(tbl_schema->get_subpartition_key_info().is_rowkey_column(column_id, is_part_key))) {
LOG_WARN("check if the column_id is subpartition key failed", K(ret), K(table_id), K(column_id));
}
}
}
return ret;
}
int ObSchemaChecker::get_can_read_index_array(
uint64_t table_id, uint64_t* index_tid_array, int64_t& size, bool with_mv) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id || size <= 0) || OB_ISNULL(index_tid_array)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(size), K(index_tid_array), K(ret));
} else if (OB_NOT_NULL(sql_schema_mgr_)) {
if (OB_FAIL(sql_schema_mgr_->get_can_read_index_array(table_id, index_tid_array, size, with_mv))) {
LOG_WARN("failed to get_can_read_index_array", K(table_id), K(ret));
}
} else {
if (OB_FAIL(schema_mgr_->get_can_read_index_array(table_id, index_tid_array, size, with_mv))) {
LOG_WARN("failed to get_can_read_index_array", K(table_id), K(ret));
}
}
return ret;
}
int ObSchemaChecker::get_can_write_index_array(
uint64_t table_id, uint64_t* index_tid_array, int64_t& size, bool only_global) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id || size <= 0) || OB_ISNULL(index_tid_array)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(table_id), K(size), K(index_tid_array), K(ret));
} else if (OB_FAIL(schema_mgr_->get_can_write_index_array(table_id, index_tid_array, size, only_global))) {
LOG_WARN("failed to get_can_write_index_array", K(table_id), K(ret));
} else {
}
return ret;
}
int ObSchemaChecker::column_is_key(uint64_t table_id, uint64_t column_id, bool& is_key)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else {
ret = schema_mgr_->column_is_key(table_id, column_id, is_key);
}
return ret;
}
int ObSchemaChecker::get_tenant_id(const ObString& tenant_name, uint64_t& tenant_id)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(tenant_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant_name", K(tenant_name), K(ret));
} else if (OB_FAIL(schema_mgr_->get_tenant_id(tenant_name, tenant_id))) {
LOG_WARN("get tenant id failed", K(tenant_name), K(ret));
} else if (OB_INVALID_ID == tenant_id) {
ret = OB_TENANT_NOT_EXIST;
LOG_WARN("tenant is not exist", K(tenant_name), K(ret));
}
return ret;
}
int ObSchemaChecker::get_tenant_info(const uint64_t& tenant_id, const ObTenantSchema*& tenant_schema)
{
int ret = OB_SUCCESS;
tenant_schema = NULL;
const ObTenantSchema* tenant = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant_id", K(tenant_id), K(ret));
} else if (OB_FAIL(schema_mgr_->get_tenant_info(tenant_id, tenant))) {
LOG_WARN("get tenant schema failed", K(ret), K(tenant_id));
} else if (NULL == tenant) {
ret = OB_TENANT_NOT_EXIST;
LOG_WARN("tenant is not exist", K(tenant_id), K(ret));
} else {
tenant_schema = tenant;
}
return ret;
}
int ObSchemaChecker::get_sys_variable_schema(const uint64_t& tenant_id, const ObSysVariableSchema*& sys_variable_schema)
{
int ret = OB_SUCCESS;
sys_variable_schema = NULL;
const ObSysVariableSchema* sys_variable = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant_id", K(tenant_id), K(ret));
} else if (OB_FAIL(schema_mgr_->get_sys_variable_schema(tenant_id, sys_variable))) {
LOG_WARN("get tenant schema failed", K(ret), K(tenant_id));
} else if (NULL == sys_variable) {
ret = OB_TENANT_NOT_EXIST;
LOG_WARN("tenant is not exist", K(tenant_id), K(ret));
} else {
sys_variable_schema = sys_variable;
}
return ret;
}
int ObSchemaChecker::get_database_schema(
const uint64_t tenant_id, const uint64_t database_id, const ObDatabaseSchema*& database_schema)
{
int ret = OB_SUCCESS;
database_schema = NULL;
const ObDatabaseSchema* database = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == database_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_id), K(ret));
} else if (OB_FAIL(schema_mgr_->get_database_schema(tenant_id, database_id, database))) {
LOG_WARN("get database schema failed", K(tenant_id), K(database_id), K(ret));
} else if (NULL == database) {
ret = OB_ERR_BAD_DATABASE;
LOG_WARN("fail to get database schema", K(tenant_id), K(database_id), K(ret));
} else {
database_schema = database;
}
return ret;
}
int ObSchemaChecker::get_fulltext_column(
uint64_t table_id, const ColumnReferenceSet& column_set, const ObColumnSchemaV2*& column_schema) const
{
int ret = OB_SUCCESS;
const ObTableSchema* table = NULL;
if (OB_FAIL(get_table_schema(table_id, table))) {
LOG_WARN("get table schema failed", K(ret), K(table_id));
} else if (NULL == table) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("table is not exist", K(table_id));
} else {
column_schema = table->get_fulltext_column(column_set);
}
return ret;
}
int ObSchemaChecker::check_column_has_index(uint64_t table_id, uint64_t column_id, bool& has_index)
{
int ret = OB_SUCCESS;
const ObColumnSchemaV2* col_schema = NULL;
uint64_t index_tid_array[OB_MAX_INDEX_PER_TABLE];
int64_t index_cnt = OB_MAX_INDEX_PER_TABLE;
has_index = false;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_FAIL(get_can_read_index_array(table_id, index_tid_array, index_cnt, true))) {
LOG_WARN("get table schema failed", K(table_id));
}
for (int64_t i = 0; OB_SUCC(ret) && !has_index && i < index_cnt; ++i) {
if (OB_FAIL(get_column_schema_inner(index_tid_array[i], column_id, col_schema))) {
LOG_WARN("get column schema failed", K(ret), K(index_tid_array[i]), K(column_id));
} else if (col_schema != NULL && col_schema->is_index_column()) {
has_index = true;
}
}
return ret;
}
int ObSchemaChecker::get_syn_info(const uint64_t tenant_id, const ObString& database_name, const ObString& sym_name,
ObString& obj_dbname, ObString& obj_name, bool& exists)
{
int ret = OB_SUCCESS;
uint64_t db_id = OB_INVALID_ID;
const ObSimpleSynonymSchema* synonym_schema = NULL;
exists = false;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K_(is_inited));
} else if (OB_FAIL(get_database_id(tenant_id, database_name, db_id))) {
LOG_WARN("get database id failed", K(ret));
} else if (OB_FAIL(schema_mgr_->get_synonym_info(tenant_id, db_id, sym_name, synonym_schema))) {
LOG_WARN("get_synonym_schema_with_name failed", K(ret));
} else if (synonym_schema == NULL) {
ret = OB_TABLE_NOT_EXIST;
LOG_WARN("sym is not exist", K(tenant_id), K(database_name), K(sym_name), K(ret));
} else {
const ObSimpleDatabaseSchema* db_schema = NULL;
OZ(schema_mgr_->get_database_schema(synonym_schema->get_object_database_id(), db_schema));
if (OB_SUCC(ret) && db_schema != NULL) {
exists = true;
OX(obj_dbname = db_schema->get_database_name_str());
OX(obj_name = synonym_schema->get_object_name_str());
}
}
return ret;
}
int ObSchemaChecker::check_has_all_server_readonly_replica(uint64_t table_id, bool& has)
{
int ret = OB_SUCCESS;
const ObTableSchema* table_schema = NULL;
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(ret), K(is_inited_));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid table id", K(ret), K(table_id));
} else if (OB_FAIL(get_table_schema_inner(table_id, table_schema))) {
LOG_WARN("fail to get table schema", K(ret), K(table_id));
} else if (OB_UNLIKELY(NULL == table_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table schema null", K(ret), KP(table_schema), K(table_id));
} else if (OB_FAIL(table_schema->check_has_all_server_readonly_replica(*schema_mgr_, has))) {
LOG_WARN("fail to check has all server readonly replica", K(ret), K(table_id));
} else {
} // no more to do
return ret;
}
int ObSchemaChecker::check_is_all_server_readonly_replica(uint64_t table_id, bool& is)
{
int ret = OB_SUCCESS;
const ObTableSchema* table_schema = NULL;
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(ret), K(is_inited_));
} else if (OB_UNLIKELY(OB_INVALID_ID == table_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid table id", K(ret), K(table_id));
} else if (OB_FAIL(get_table_schema_inner(table_id, table_schema))) {
LOG_WARN("fail to get table schema", K(ret), K(table_id));
} else if (OB_UNLIKELY(NULL == table_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table schema null", K(ret), KP(table_schema), K(table_id));
} else if (OB_FAIL(table_schema->check_is_all_server_readonly_replica(*schema_mgr_, is))) {
LOG_WARN("fail to check is all server readonly replica", K(ret), K(table_id));
} else {
} // no more to do
return ret;
}
int ObSchemaChecker::get_synonym_info_version(uint64_t synonym_id, int64_t& synonym_version)
{
return schema_mgr_->get_synonym_info_version(synonym_id, synonym_version);
}
int ObSchemaChecker::get_synonym_schema(uint64_t tenant_id, const uint64_t database_id, const ObString& synonym_name,
uint64_t& object_database_id, uint64_t& synonym_id, ObString& object_table_name, bool& exist)
{
return schema_mgr_->get_object_with_synonym(
tenant_id, database_id, synonym_name, object_database_id, synonym_id, object_table_name, exist);
}
int ObSchemaChecker::get_obj_info_recursively_with_synonym(const uint64_t tenant_id, const uint64_t syn_db_id,
const common::ObString& syn_name, uint64_t& obj_db_id, common::ObString& obj_name, ObIArray<uint64_t>& syn_id_arr,
bool is_first_called)
{
int ret = OB_SUCCESS;
uint64_t syn_id = OB_INVALID_ID;
bool syn_exist = false;
if (OB_FAIL(get_synonym_schema(tenant_id, syn_db_id, syn_name, obj_db_id, syn_id, obj_name, syn_exist))) {
LOG_WARN("get_obj_info_recursively_with_synonym failed", K(ret), K(tenant_id), K(syn_db_id), K(syn_name));
}
if (OB_SUCC(ret)) {
if (!syn_exist) {
if (is_first_called) {
ret = OB_SYNONYM_NOT_EXIST;
LOG_WARN("synonym not exist", K(ret), K(tenant_id), K(syn_db_id), K(syn_name));
} else {
}
} else {
uint64_t new_syn_db_id = obj_db_id;
ObString new_syn_obj_name = obj_name;
if (OB_UNLIKELY(has_exist_in_array(syn_id_arr, syn_id))) {
ret = OB_ERR_LOOP_OF_SYNONYM;
LOG_WARN("duplicated synonym id", K(ret), K(syn_id), K(syn_id_arr));
} else if (OB_FAIL(syn_id_arr.push_back(syn_id))) {
LOG_WARN("push back syn_id failed", K(ret), K(syn_id), K(syn_id_arr));
} else if (OB_FAIL(SMART_CALL(get_obj_info_recursively_with_synonym(
tenant_id, new_syn_db_id, new_syn_obj_name, obj_db_id, obj_name, syn_id_arr, false)))) {
LOG_WARN("get_obj_info_recursively_with_synonym failed",
K(ret),
K(tenant_id),
K(new_syn_db_id),
K(new_syn_obj_name));
}
}
}
return ret;
}
int ObSchemaChecker::add_fake_cte_schema(share::schema::ObTableSchema* tbl_schema)
{
int ret = OB_SUCCESS;
bool dup_schame = false;
for (int64_t i = 0; OB_SUCC(ret) && i < tmp_cte_schemas_.count(); i++) {
if (tbl_schema->get_table_name() == tmp_cte_schemas_.at(i)->get_table_name()) {
dup_schame = true;
}
}
if (!dup_schame) {
if (OB_FAIL(tmp_cte_schemas_.push_back(tbl_schema))) {
LOG_WARN("push back cte schema failed");
}
}
return ret;
}
int ObSchemaChecker::find_fake_cte_schema(common::ObString tblname, bool& exist)
{
int ret = OB_SUCCESS;
exist = false;
for (int64_t i = 0; OB_SUCC(ret) && i < tmp_cte_schemas_.count(); ++i) {
if (tmp_cte_schemas_.at(i)->get_table_name_str() == tblname) {
exist = true;
break;
}
}
return ret;
}
int ObSchemaChecker::get_schema_version(
uint64_t table_id, share::schema::ObSchemaType schema_type, int64_t& schema_version)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(schema_mgr_)) {
ret = OB_NOT_INIT;
LOG_WARN("schema mgr is null");
} else {
ret = schema_mgr_->get_schema_version_v2(schema_type, table_id, schema_version);
}
return ret;
}
int ObSchemaChecker::get_tablegroup_schema(
const int64_t tenant_id, const ObString& tablegroup_name, const ObTablegroupSchema*& tablegroup_schema)
{
int ret = OB_SUCCESS;
uint64_t tablegroup_id = OB_INVALID_ID;
if (OB_INVALID_ID == tenant_id || tablegroup_name.empty()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(tablegroup_name));
} else if (OB_ISNULL(schema_mgr_)) {
ret = OB_NOT_INIT;
LOG_WARN("invalid argument", K(ret), K(schema_mgr_));
} else if (OB_FAIL(schema_mgr_->get_tablegroup_id(tenant_id, tablegroup_name, tablegroup_id))) {
LOG_WARN("fail to get tablegroup id", K(ret), K(tenant_id), K(tablegroup_name));
} else if (OB_INVALID_ID == tablegroup_id) {
ret = OB_TABLEGROUP_NOT_EXIST;
LOG_WARN("table group not exist", K(ret), K(tablegroup_id));
} else if (OB_FAIL(schema_mgr_->get_tablegroup_schema(tablegroup_id, tablegroup_schema))) {
LOG_WARN("fail to get tablegroup schema", K(ret), K(tablegroup_id));
} else if (OB_ISNULL(tablegroup_schema)) {
ret = OB_TABLEGROUP_NOT_EXIST;
LOG_WARN("get invalid tablegroup schema", K(ret), K(tenant_id), K(tablegroup_name));
}
return ret;
}
int ObSchemaChecker::get_udf_info(
uint64_t tenant_id, const common::ObString& udf_name, const share::schema::ObUDF*& udf_info, bool& exist)
{
int ret = OB_SUCCESS;
if (OB_INVALID_ID == tenant_id || udf_name.empty()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(udf_name));
} else if (OB_ISNULL(schema_mgr_)) {
ret = OB_NOT_INIT;
LOG_WARN("invalid argument", K(ret), K(schema_mgr_));
} else if (OB_FAIL(schema_mgr_->get_udf_info(tenant_id, udf_name, udf_info, exist))) {
LOG_WARN("failed to get udf schema", K(ret));
}
return ret;
}
int ObSchemaChecker::check_sequence_exist_with_name(const uint64_t tenant_id, const uint64_t database_id,
const common::ObString& sequence_name, bool& exists, uint64_t& sequence_id)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K_(is_inited));
} else if (OB_FAIL(schema_mgr_->check_sequence_exist_with_name(
tenant_id, database_id, sequence_name, exists, sequence_id))) {
LOG_WARN("get sequence id failed", K(tenant_id), K(database_id), K(database_id), K(sequence_name), K(ret));
}
return ret;
}
int ObSchemaChecker::get_sequence_id(const uint64_t tenant_id, const common::ObString& database_name,
const common::ObString& sequence_name, uint64_t& sequence_id)
{
int ret = OB_SUCCESS;
bool is_exist = false;
uint64_t database_id = 0;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K_(is_inited));
} else if (OB_FAIL(get_database_id(tenant_id, database_name, database_id))) {
LOG_WARN("fail to get_database_id", K(ret));
} else if (OB_FAIL(schema_mgr_->check_sequence_exist_with_name(
tenant_id, database_id, sequence_name, is_exist, sequence_id))) {
LOG_WARN("get sequence id failed", K(tenant_id), K(database_id), K(database_id), K(sequence_name), K(ret));
} else if (!is_exist) {
ret = OB_ERR_SEQ_NOT_EXIST;
}
return ret;
}
// only use in oracle mode
int ObSchemaChecker::get_idx_schema_by_origin_idx_name(const uint64_t tenant_id, const uint64_t database_id,
const ObString& index_name, const ObTableSchema*& table_schema)
{
int ret = OB_SUCCESS;
table_schema = NULL;
const ObTableSchema* table = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == database_id || index_name.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(tenant_id), K(database_id), K(index_name), K(ret));
} else if (OB_FAIL(schema_mgr_->get_idx_schema_by_origin_idx_name(tenant_id, database_id, index_name, table))) {
LOG_WARN("get table schema failed", K(tenant_id), K(database_id), K(index_name), K(ret));
} else {
if (NULL == table) {
LOG_WARN("index table schema is null", K(index_name), K(ret));
} else if (false == table->is_tmp_table() && 0 != table->get_session_id() &&
OB_INVALID_ID != schema_mgr_->get_session_id()) {
const ObDatabaseSchema* db_schema = NULL;
if (OB_FAIL(schema_mgr_->get_database_schema(tenant_id, database_id, db_schema))) {
LOG_WARN("get database schema failed", K(tenant_id), K(database_id), K(ret));
} else if (NULL == db_schema) {
ret = OB_ERR_BAD_DATABASE;
LOG_WARN("fail to get database schema", K(tenant_id), K(database_id), K(ret));
} else {
ret = OB_TABLE_NOT_EXIST;
LOG_USER_ERROR(OB_TABLE_NOT_EXIST, db_schema->get_database_name(), to_cstring(index_name));
}
} else {
table_schema = table;
}
}
return ret;
}
int ObSchemaChecker::get_profile_id(
const uint64_t tenant_id, const common::ObString& profile_name, uint64_t& profile_id)
{
int ret = OB_SUCCESS;
const ObProfileSchema* schema = NULL;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K_(is_inited));
} else if (OB_FAIL(schema_mgr_->get_profile_schema_by_name(tenant_id, profile_name, schema))) {
LOG_WARN("get profile id failed", K(ret));
} else if (OB_ISNULL(schema)) {
ret = OB_ERR_PROFILE_STRING_DOES_NOT_EXIST;
LOG_USER_ERROR(OB_ERR_PROFILE_STRING_DOES_NOT_EXIST, profile_name.length(), profile_name.ptr());
} else {
profile_id = schema->get_profile_id();
}
return ret;
}
int ObSchemaChecker::get_dblink_id(uint64_t tenant_id, const ObString& dblink_name, uint64_t& dblink_id)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(schema_mgr_)) {
ret = OB_NOT_INIT;
LOG_WARN("invalid argument", K(ret), K(schema_mgr_));
} else if (OB_FAIL(schema_mgr_->get_dblink_id(tenant_id, dblink_name, dblink_id))) {
LOG_WARN("failed to get dblink id", K(ret), K(tenant_id), K(dblink_name));
}
return ret;
}
int ObSchemaChecker::get_dblink_user(const uint64_t tenant_id, const common::ObString& dblink_name,
common::ObString& dblink_user, common::ObIAllocator& allocator)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(schema_mgr_)) {
ret = OB_NOT_INIT;
LOG_WARN("invalid argument", K(ret), K(schema_mgr_));
} else if (OB_FAIL(schema_mgr_->get_dblink_user(tenant_id, dblink_name, dblink_user, allocator))) {
LOG_WARN("failed to get dblink id", K(ret), K(tenant_id), K(dblink_name));
}
return ret;
}
int ObSchemaChecker::get_table_schema_inner(uint64_t table_id, const ObTableSchema*& table_schema) const
{
int ret = OB_SUCCESS;
if (OB_NOT_NULL(sql_schema_mgr_)) {
OZ(sql_schema_mgr_->get_table_schema(table_id, table_schema), table_id);
} else {
OV(OB_NOT_NULL(schema_mgr_));
OZ(schema_mgr_->get_table_schema(table_id, table_schema), table_id);
}
return ret;
}
int ObSchemaChecker::get_column_schema_inner(
uint64_t table_id, const ObString& column_name, const ObColumnSchemaV2*& column_schema) const
{
int ret = OB_SUCCESS;
if (OB_NOT_NULL(sql_schema_mgr_)) {
OZ(sql_schema_mgr_->get_column_schema(table_id, column_name, column_schema), table_id, column_name);
} else {
OV(OB_NOT_NULL(schema_mgr_));
OZ(schema_mgr_->get_column_schema(table_id, column_name, column_schema), table_id, column_name);
}
return ret;
}
int ObSchemaChecker::get_column_schema_inner(
uint64_t table_id, const uint64_t column_id, const ObColumnSchemaV2*& column_schema) const
{
int ret = OB_SUCCESS;
if (OB_NOT_NULL(sql_schema_mgr_)) {
OZ(sql_schema_mgr_->get_column_schema(table_id, column_id, column_schema), table_id, column_id);
} else {
OV(OB_NOT_NULL(schema_mgr_));
OZ(schema_mgr_->get_column_schema(table_id, column_id, column_schema), table_id, column_id);
}
return ret;
}
int ObSchemaChecker::get_object_type_with_view_info(ObIAllocator* allocator, void* param_org, const uint64_t tenant_id,
const common::ObString& database_name, const common::ObString& table_name, share::schema::ObObjectType& object_type,
uint64_t& object_id, void*& view_query, bool is_directory, common::ObString& object_db_name, bool explicit_db,
const common::ObString& prev_table_name) /* ObSelectStmt* */
{
int ret = OB_SUCCESS;
object_type = ObObjectType::INVALID;
object_id = OB_INVALID_ID;
const share::schema::ObTableSchema* table_schema = NULL;
uint64_t database_id = OB_INVALID_ID;
CK(allocator != NULL);
CK(param_org != NULL);
object_db_name = database_name;
ObResolverParams& param = *static_cast<ObResolverParams*>(param_org);
if (OB_FAIL(get_database_id(tenant_id, database_name, database_id))) {
if (share::is_oracle_mode() && ret == OB_ERR_BAD_DATABASE) {
ret = OB_TABLE_NOT_EXIST;
}
} else if (false == is_directory) {
ret = get_table_schema(tenant_id, database_name, table_name, false, table_schema);
if (OB_TABLE_NOT_EXIST == ret) {
if (lib::is_oracle_mode()) {
ret = get_idx_schema_by_origin_idx_name(tenant_id, database_id, table_name, table_schema);
if (OB_SUCC(ret) && table_schema == NULL) {
ret = OB_TABLE_NOT_EXIST;
}
}
}
if (OB_SUCC(ret) && table_schema != NULL) {
if (table_schema->is_index_table()) {
object_type = ObObjectType::INDEX;
} else {
object_type = ObObjectType::TABLE;
}
object_id = table_schema->get_table_id();
if (table_schema->is_view_table() && !table_schema->is_materialized_view()) {
ObSelectStmt* select_stmt = NULL;
// ObStmtFactory stmt_factory(*allocator);
// ObRawExprFactory expr_factory(*allocator);
if (OB_FAIL(observer::ObTableColumns::resolve_view_definition(allocator,
param.session_info_,
schema_mgr_,
*table_schema,
select_stmt,
*param.expr_factory_,
*param.stmt_factory_))) {
LOG_WARN("failed to resolve view definition", K(table_name), K(ret));
} else if (OB_UNLIKELY(NULL == select_stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("select_stmt is NULL", K(ret));
} else {
view_query = select_stmt;
}
}
}
// check sequence
if (OB_TABLE_NOT_EXIST == ret) {
uint64_t sequence_id = 0;
if (OB_FAIL(get_sequence_id(tenant_id, database_name, table_name, sequence_id))) {
if (OB_ERR_SEQ_NOT_EXIST == ret) {
ret = OB_TABLE_NOT_EXIST;
}
} else {
object_type = ObObjectType::SEQUENCE;
object_id = sequence_id;
}
}
// check synonym
if (OB_TABLE_NOT_EXIST == ret) {
ObString obj_db_name;
ObString obj_name;
bool exists = false;
ret = OB_SUCCESS;
OZ(get_syn_info(tenant_id, database_name, table_name, obj_db_name, obj_name, exists));
if (OB_SUCC(ret) && exists) {
object_db_name = obj_db_name;
OZ(SMART_CALL(get_object_type_with_view_info(allocator,
param_org,
tenant_id,
obj_db_name,
obj_name,
object_type,
object_id,
view_query,
is_directory,
object_db_name,
false,
ObString(""))));
}
}
// check public synonym
if (OB_TABLE_NOT_EXIST == ret) {
ObString obj_db_name;
ObString obj_name;
bool exists = false;
ret = OB_SUCCESS;
if (explicit_db) {
ret = OB_TABLE_NOT_EXIST;
} else {
ObString pub_db_name =
lib::is_oracle_mode() ? ObString(OB_ORA_PUBLIC_SCHEMA_NAME) : ObString(OB_PUBLIC_SCHEMA_NAME);
OZ(get_syn_info(tenant_id, pub_db_name, table_name, obj_db_name, obj_name, exists));
if (OB_SUCC(ret) && exists) {
if (prev_table_name == obj_name) {
ret = OB_TABLE_NOT_EXIST;
} else {
object_db_name = obj_db_name;
OZ(SMART_CALL(get_object_type_with_view_info(allocator,
param_org,
tenant_id,
obj_db_name,
obj_name,
object_type,
object_id,
view_query,
is_directory,
object_db_name,
false,
table_name))); /* false */
}
}
}
}
} else {
// if directory, support it's a directory, to do after create directory
object_type = ObObjectType::DIRECTORY;
object_id = OBJ_ID_FOR_DIR;
ret = OB_SUCCESS;
}
if (OB_FAIL(ret)) {
LOG_WARN("get_object_type_with_view_info failed", K(tenant_id), K(database_name), K(table_name), K(ret));
}
return ret;
}
int ObSchemaChecker::get_object_type(const uint64_t tenant_id, const common::ObString& database_name,
const common::ObString& table_name, share::schema::ObObjectType& object_type, uint64_t& object_id,
common::ObString& object_db_name, bool is_directory, bool explicit_db, const common::ObString& prev_table_name)
{
int ret = OB_SUCCESS;
object_type = ObObjectType::INVALID;
object_id = OB_INVALID_ID;
const share::schema::ObTableSchema* table_schema = NULL;
uint64_t database_id = OB_INVALID_ID;
object_db_name = database_name;
if (OB_FAIL(get_database_id(tenant_id, database_name, database_id))) {
if (share::is_oracle_mode() && ret == OB_ERR_BAD_DATABASE) {
ret = OB_TABLE_NOT_EXIST;
}
} else if (false == is_directory) {
ret = get_table_schema(tenant_id, database_name, table_name, false, table_schema);
if (OB_TABLE_NOT_EXIST == ret) {
if (lib::is_oracle_mode()) {
ret = get_idx_schema_by_origin_idx_name(tenant_id, database_id, table_name, table_schema);
if (OB_SUCC(ret)) {
if (table_schema == NULL) {
ret = OB_TABLE_NOT_EXIST;
}
}
}
}
if (OB_SUCC(ret) && table_schema != NULL) {
if (table_schema->is_index_table()) {
object_type = ObObjectType::INDEX;
} else {
object_type = ObObjectType::TABLE;
}
object_id = table_schema->get_table_id();
}
// check sequence
if (OB_TABLE_NOT_EXIST == ret) {
uint64_t sequence_id = 0;
if (OB_FAIL(get_sequence_id(tenant_id, database_name, table_name, sequence_id))) {
if (OB_ERR_SEQ_NOT_EXIST == ret) {
ret = OB_TABLE_NOT_EXIST;
}
} else {
object_type = ObObjectType::SEQUENCE;
object_id = sequence_id;
}
}
// check synonym
if (OB_TABLE_NOT_EXIST == ret) {
ObString obj_db_name;
ObString obj_name;
bool exists = false;
ret = OB_SUCCESS;
OZ(get_syn_info(tenant_id, database_name, table_name, obj_db_name, obj_name, exists));
if (OB_SUCC(ret) && exists) {
object_db_name = obj_db_name;
OZ(SMART_CALL(get_object_type(tenant_id,
obj_db_name,
obj_name,
object_type,
object_id,
object_db_name,
is_directory,
false,
ObString(""))));
}
}
// check public synonym
if (OB_TABLE_NOT_EXIST == ret) {
ObString obj_db_name;
ObString obj_name;
bool exists = false;
ret = OB_SUCCESS;
if (explicit_db) {
ret = OB_TABLE_NOT_EXIST;
} else {
ObString pub_db_name =
lib::is_oracle_mode() ? ObString(OB_ORA_PUBLIC_SCHEMA_NAME) : ObString(OB_PUBLIC_SCHEMA_NAME);
OZ(get_syn_info(tenant_id, pub_db_name, table_name, obj_db_name, obj_name, exists));
if (OB_SUCC(ret) && exists) {
if (prev_table_name == obj_name) {
ret = OB_TABLE_NOT_EXIST;
} else {
object_db_name = obj_db_name;
OZ(SMART_CALL(get_object_type(tenant_id,
obj_db_name,
obj_name,
object_type,
object_id,
object_db_name,
is_directory,
false,
table_name)));
}
}
}
}
} else {
// if directory, support it's a directory, to do after create directory
object_type = ObObjectType::DIRECTORY;
object_id = OBJ_ID_FOR_DIR;
ret = OB_SUCCESS;
}
if (OB_FAIL(ret)) {
LOG_WARN("get_object_type failed", K(tenant_id), K(database_name), K(table_name), K(ret));
}
return ret;
}
/* check privilege of grant role priv */
int ObSchemaChecker::check_ora_grant_role_priv(const uint64_t tenant_id, const uint64_t user_id,
const ObSEArray<uint64_t, 4>& role_granted_id_array, const ObIArray<uint64_t>& role_id_array)
{
int ret = OB_SUCCESS;
if (is_ora_priv_check()) {
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (FALSE_IT(schema_mgr_ == NULL)) {
} else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_2260) {
OZ(ObOraSysChecker::check_ora_grant_role_priv(
*schema_mgr_, tenant_id, user_id, role_granted_id_array, role_id_array));
}
}
return ret;
}
/* check privilege of grant sys priv */
int ObSchemaChecker::check_ora_grant_sys_priv(const uint64_t tenant_id, const uint64_t user_id,
const share::ObRawPrivArray& sys_priv_array, const ObIArray<uint64_t>& role_id_array)
{
int ret = OB_SUCCESS;
if (is_ora_priv_check()) {
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (FALSE_IT(schema_mgr_ == NULL)) {
} else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_2260) {
OZ(ObOraSysChecker::check_ora_grant_sys_priv(*schema_mgr_, tenant_id, user_id, sys_priv_array, role_id_array));
}
}
return ret;
}
/* check privilege of grant obj priv */
int ObSchemaChecker::check_ora_grant_obj_priv(const uint64_t tenant_id, const uint64_t user_id,
const common::ObString& db_name, const uint64_t obj_id, const uint64_t obj_type,
const share::ObRawObjPrivArray& table_priv_array, const ObSEArray<uint64_t, 4>& ins_col_ids,
const ObSEArray<uint64_t, 4>& upd_col_ids, const ObSEArray<uint64_t, 4>& ref_col_ids, uint64_t& grantor_id_out,
const ObIArray<uint64_t>& role_id_array)
{
int ret = OB_SUCCESS;
if (is_ora_priv_check()) {
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (FALSE_IT(schema_mgr_ == NULL)) {
} else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_2260) {
OZ(ObOraSysChecker::check_ora_grant_obj_priv(*schema_mgr_,
tenant_id,
user_id,
db_name,
obj_id,
obj_type,
table_priv_array,
ins_col_ids,
upd_col_ids,
ref_col_ids,
grantor_id_out,
role_id_array));
}
}
return ret;
}
int ObSchemaChecker::check_ora_ddl_priv(const uint64_t tenant_id, const uint64_t user_id,
const common::ObString& database_name, const sql::stmt::StmtType stmt_type, const ObIArray<uint64_t>& role_id_array)
{
int ret = OB_SUCCESS;
if (is_ora_priv_check()) {
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (FALSE_IT(schema_mgr_ == NULL)) {
} else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_2260) {
if (is_ora_lbacsys_user(user_id) && is_lbca_op()) {
// need not check
} else {
OZ(ObOraSysChecker::check_ora_ddl_priv(
*schema_mgr_, tenant_id, user_id, database_name, stmt_type, role_id_array),
K(tenant_id),
K(user_id),
K(database_name),
K(stmt_type),
K(role_id_array));
}
}
}
return ret;
}
int ObSchemaChecker::check_access_to_obj(const uint64_t tenant_id, const uint64_t user_id, const uint64_t obj_id,
const sql::stmt::StmtType stmt_type, const ObIArray<uint64_t>& role_id_array, bool& accessible)
{
int ret = OB_SUCCESS;
accessible = false;
if (is_ora_priv_check()) {
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (OB_ISNULL(schema_mgr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("schema_mgr_ is NULL", K(ret), K(tenant_id), K(user_id), K(obj_id));
} else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_2260) {
if (is_ora_lbacsys_user(user_id) && is_lbca_op()) {
accessible = true;
} else {
switch (stmt_type) {
case stmt::T_CREATE_VIEW: {
OZ(ObOraSysChecker::check_access_to_obj(*schema_mgr_,
tenant_id,
user_id,
PRIV_ID_CREATE_ANY_VIEW,
static_cast<uint64_t>(share::schema::ObObjectType::TABLE),
obj_id,
role_id_array,
accessible),
K(tenant_id),
K(user_id),
K(stmt_type),
K(role_id_array));
break;
}
default: {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexcepted stmt_type", K(ret), K(stmt_type));
break;
}
}
}
}
}
return ret;
}
// int ObSchemaChecker::check_ora_ddl_priv(
// const uint64_t tenant_id,
// const uint64_t user_id,
// const common::ObString &database_name,
// const bool is_replace,
// const stmt::StmtType stmt_type,
// const stmt::StmtType stmt_type2)
// {
// int ret = OB_SUCCESS;
// if (IS_NOT_INIT) {
// ret = OB_NOT_INIT;
// LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
// } else if (FALSE_IT(schema_mgr_ == NULL)) {
// } else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_3000) {
// OZ (ObOraSysChecker::check_ora_ddl_priv(*schema_mgr_,
// tenant_id,
// user_id,
// database_name,
// stmt_type),
// K(tenant_id), K(user_id), K(database_name), K(stmt_type));
// if (OB_SUCC(ret) && is_replace) {
// OZ (ObOraSysChecker::check_ora_ddl_priv(*schema_mgr_,
// tenant_id,
// user_id,
// database_name,
// stmt_type2),
// K(tenant_id), K(user_id), K(database_name), K(stmt_type2));
// }
// }
// return ret;
// }
// for some ddl, both system or obj priv is ok.
// Such as: alter table
// create index
int ObSchemaChecker::check_ora_ddl_priv(const uint64_t tenant_id, const uint64_t user_id,
const common::ObString& database_name, const uint64_t obj_id, const uint64_t obj_type,
const sql::stmt::StmtType stmt_type, const ObIArray<uint64_t>& role_id_array)
{
int ret = OB_SUCCESS;
if (is_ora_priv_check()) {
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("schema checker is not inited", K(is_inited_), K(ret));
} else if (FALSE_IT(schema_mgr_ == NULL)) {
} else if (GET_MIN_CLUSTER_VERSION() >= CLUSTER_VERSION_2260) {
if (is_ora_lbacsys_user(user_id) && is_lbca_op()) {
// need not check
} else {
OZ(ObOraSysChecker::check_ora_ddl_priv(
*schema_mgr_, tenant_id, user_id, database_name, obj_id, obj_type, stmt_type, role_id_array),
K(tenant_id),
K(user_id),
K(database_name),
K(obj_id),
K(obj_type),
K(stmt_type));
}
}
}
return ret;
}
bool ObSchemaChecker::is_ora_priv_check()
{
if (lib::is_oracle_mode() && GCONF._enable_oracle_priv_check)
return true;
else
return false;
}
} // end of namespace sql
} // end of namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink