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

alter ob_tcp_invited_nodes max_length=64K

Browse Source
This commit is contained in:
zhjc1124
2023-10-12 02:39:55 +00:00
committed by ob-robot
parent fc85a979ab
commit e621b30dd9
15 changed files with 46 additions and 658 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
deps/oblib/src/lib/ob_define.h vendored
View File

@ -1773,6 +1773,7 @@ const int64_t OB_DUMP_ROOT_TABLE_TYPE = 1;
const int64_t OB_DUMP_UNUSUAL_TABLET_TYPE = 2;
const int64_t OB_MAX_SYS_VAR_NON_STRING_VAL_LENGTH = 128;
const int64_t OB_MAX_SYS_VAR_VAL_LENGTH = 4096;//original 128 is too small
const int64_t OB_MAX_TCP_INVITED_NODES_LENGTH = 64 * 1024; // 64K
// bitset defines
const int64_t OB_DEFAULT_BITSET_SIZE = OB_MAX_TABLE_NUM_PER_STMT;

1
src/share/CMakeLists.txt
View File

@ -217,7 +217,6 @@ ob_set_subtarget(ob_share common_mixed
restore/ob_import_table_struct.cpp
restore/ob_import_util.cpp
restore/ob_recover_table_util.cpp
restore/ob_restore_args.cpp
restore/ob_restore_uri_parser.cpp
restore/ob_ls_restore_status.cpp
restore/ob_restore_type.cpp

1
src/share/ob_cluster_version.h
View File

@ -189,6 +189,7 @@ cal_version(const uint64_t major, const uint64_t minor, const uint64_t major_pat
#define DATA_VERSION_4_1_0_2 (oceanbase::common::cal_version(4, 1, 0, 2))
#define DATA_VERSION_4_2_0_0 (oceanbase::common::cal_version(4, 2, 0, 0))
#define DATA_VERSION_4_2_1_0 (oceanbase::common::cal_version(4, 2, 1, 0))
#define DATA_VERSION_4_2_1_1 (oceanbase::common::cal_version(4, 2, 1, 1))
#define DATA_VERSION_4_2_2_0 (oceanbase::common::cal_version(4, 2, 2, 0))
#define DATA_VERSION_4_3_0_0 (oceanbase::common::cal_version(4, 3, 0, 0))

1
src/share/ob_rpc_struct.h
View File

@ -42,7 +42,6 @@
#include "share/schema/ob_dependency_info.h"
#include "share/schema/ob_trigger_info.h"
#include "share/ob_storage_format.h"
#include "share/restore/ob_restore_args.h" // ObRestoreArgs
#include "share/io/ob_io_calibration.h" // ObIOBenchResult
#include "rootserver/ob_rs_job_table_operator.h"
#include "sql/executor/ob_task_id.h"

219
src/share/restore/ob_restore_args.cpp
View File

@ -1,219 +0,0 @@
/**
* 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 SHARE
#include "share/restore/ob_restore_args.h"
#include "lib/utility/ob_print_utils.h"
#include <memory.h>
using namespace oceanbase::common;
using namespace oceanbase::share;
ObRestoreArgs::ObRestoreArgs()
: base_data_version_(OB_INVALID_VERSION),
curr_data_version_(OB_INVALID_VERSION),
tenant_id_(OB_INVALID_TENANT_ID),
restore_timeu_(0),
backup_schema_id_(OB_INVALID_ID),
partition_id_(-1),
schema_id_list_(),
sql_info_(),
schema_version_(0),
cluster_version_(OB_INVALID_ID),
schema_id_pair_()
{
MEMSET(uri_header_, '\0', sizeof(uri_header_));
MEMSET(cluster_name_, '\0', sizeof(cluster_name_));
MEMSET(storage_info_, '\0', OB_MAX_URI_LENGTH);
MEMSET(primary_zone_, '\0', MAX_ZONE_LENGTH);
MEMSET(locality_, '\0', MAX_LOCALITY_LENGTH);
MEMSET(pool_list_, '\0', OB_MAX_POOL_LIST_LENGTH);
MEMSET(restore_user_, '\0', OB_MAX_USERNAME_LENGTH);
MEMSET(restore_pass_, '\0', OB_MAX_PASSWORD_LENGTH);
MEMSET(tcp_invited_nodes_, '\0', OB_MAX_TCP_INVITED_NODES_LENGTH);
}
void ObRestoreArgs::reset()
{
MEMSET(uri_header_, '\0', sizeof(uri_header_));
MEMSET(cluster_name_, '\0', sizeof(cluster_name_));
MEMSET(storage_info_, '\0', OB_MAX_URI_LENGTH);
MEMSET(primary_zone_, '\0', MAX_ZONE_LENGTH);
MEMSET(locality_, '\0', MAX_LOCALITY_LENGTH);
MEMSET(pool_list_, '\0', OB_MAX_POOL_LIST_LENGTH);
MEMSET(restore_user_, '\0', OB_MAX_USERNAME_LENGTH);
MEMSET(restore_pass_, '\0', OB_MAX_PASSWORD_LENGTH);
MEMSET(tcp_invited_nodes_, '\0', OB_MAX_TCP_INVITED_NODES_LENGTH);
base_data_version_ = OB_INVALID_VERSION;
curr_data_version_ = OB_INVALID_VERSION;
tenant_id_ = OB_INVALID_TENANT_ID;
backup_schema_id_ = OB_INVALID_ID;
partition_id_ = -1;
restore_timeu_ = 0;
schema_version_ = 0;
cluster_version_ = OB_INVALID_ID;
}
bool ObRestoreArgs::is_parse_ok() const
{
bool ret = true;
if (STRLEN(storage_info_) <= 0
|| STRLEN(uri_header_) <= 0
|| STRLEN(cluster_name_) <= 0
|| STRLEN(restore_user_) <= 0
|| OB_INVALID_TENANT_ID == tenant_id_
|| 0 == restore_timeu_) {
ret = false;
}
return ret;
}
bool ObRestoreArgs::is_valid() const
{
bool ret = true;
if (!is_parse_ok() || OB_INVALID_VERSION == base_data_version_ ||
OB_INVALID_VERSION == curr_data_version_) {
ret = false;
}
return ret;
}
bool ObRestoreArgs::is_inplace_restore() const
{
// The only parameter that must be specified when creating a tenant is pool_list
// The rest include: primary zone, locality, etc. are optional
ObString pool(pool_list_);
return pool.empty();
}
//TODO(xiaochu): fill when use parse
const char *ObRestoreArgs::get_uri_header() const
{
return uri_header_;
}
const char *ObRestoreArgs::get_cluster_name() const
{
return cluster_name_;
}
//TODO(xiaochu): fill when use parse
const char *ObRestoreArgs::get_storage_info() const
{
return storage_info_;
}
OB_SERIALIZE_MEMBER(ObRestoreArgs,
primary_zone_,
locality_,
pool_list_,
base_data_version_,
curr_data_version_,
tenant_id_,
restore_timeu_,
backup_schema_id_,
partition_id_,
schema_id_list_,
schema_version_,
uri_header_,
cluster_name_,
storage_info_,
restore_user_,
restore_pass_,
tcp_invited_nodes_,
cluster_version_,
schema_id_pair_);
OB_SERIALIZE_MEMBER(ObSchemaIdPair,
schema_id_,
backup_schema_id_);
int ObRestoreArgs::set_schema_id_pairs(const common::ObIArray<ObSchemaIdPair> &pairs)
{
int ret = OB_SUCCESS;
ARRAY_FOREACH_X(pairs, idx, cnt, OB_SUCC(ret)) {
const ObSchemaIdPair &p = pairs.at(idx);
if (OB_FAIL(add_schema_id_pair(p.schema_id_, p.backup_schema_id_))) {
LOG_WARN("fail add schema id pair", K(p), K(ret));
}
}
return ret;
}
int ObRestoreArgs::add_schema_id_pair(const uint64_t index_id, const uint64_t backup_index_id)
{
int ret = OB_SUCCESS;
ObSchemaIdPair tmp;
tmp.schema_id_ = index_id;
tmp.backup_schema_id_ = backup_index_id;
if (!is_valid()) {
ret = OB_NOT_INIT;
STORAGE_LOG(WARN, "not init", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < schema_id_list_.count(); ++i) {
if (schema_id_list_.at(i).schema_id_ == index_id
|| schema_id_list_.at(i).backup_schema_id_ == backup_index_id) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "index id has exist",
K(ret), K(schema_id_list_), K(index_id), K(backup_index_id));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(schema_id_list_.push_back(tmp))) {
STORAGE_LOG(WARN, "failed to add index id list", K(ret));
}
}
return ret;
}
int ObRestoreArgs::trans_to_backup_schema_id(
const uint64_t schema_id, uint64_t &backup_schema_id) const
{
int ret = OB_ENTRY_NOT_EXIST;
if (!is_valid()) {
ret = OB_NOT_INIT;
STORAGE_LOG(WARN, "not init", K(ret));
} else {
for (int64_t i = 0; OB_ENTRY_NOT_EXIST == ret && i < schema_id_list_.count(); ++i) {
if (schema_id_list_.at(i).schema_id_ == schema_id) {
ret = OB_SUCCESS;
backup_schema_id = schema_id_list_.at(i).backup_schema_id_;
}
}
}
return ret;
}
int ObRestoreArgs::trans_from_backup_schema_id(
const uint64_t backup_schema_id, uint64_t &schema_id) const
{
int ret = OB_ENTRY_NOT_EXIST;
if (!is_valid()) {
ret = OB_NOT_INIT;
STORAGE_LOG(WARN, "not init", K(ret));
} else {
for (int64_t i = 0; OB_ENTRY_NOT_EXIST == ret && i < schema_id_list_.count(); ++i) {
if (schema_id_list_.at(i).backup_schema_id_ == backup_schema_id) {
ret = OB_SUCCESS;
schema_id = schema_id_list_.at(i).schema_id_;
}
}
}
return ret;
}

216
src/share/restore/ob_restore_args.h
View File

@ -1,216 +0,0 @@
/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#ifndef __OB_SHARE_RESTORE_OB_RESTORE_ARGS_H__
#define __OB_SHARE_RESTORE_OB_RESTORE_ARGS_H__
#include "lib/string/ob_string.h"
#include "common/data_buffer.h"
#include "lib/allocator/page_arena.h"
#include "share/ob_define.h"
namespace oceanbase
{
namespace share
{
struct ObSchemaIdPair
{
ObSchemaIdPair()
: schema_id_(common::OB_INVALID_ID), backup_schema_id_(common::OB_INVALID_ID)
{}
ObSchemaIdPair(uint64_t schema_id, uint64_t backup_schema_id)
: schema_id_(schema_id), backup_schema_id_(backup_schema_id)
{}
bool is_valid() const
{
return common::OB_INVALID_ID != schema_id_ && common::OB_INVALID_ID != backup_schema_id_;
}
uint64_t schema_id_;
uint64_t backup_schema_id_; // The schema_id of the remote backup
TO_STRING_KV(K_(schema_id), K_(backup_schema_id));
OB_UNIS_VERSION(1);
};
class ObRestoreArgs
{
public:
OB_UNIS_VERSION(1);
public:
struct OrignalSQLInfo {
OrignalSQLInfo()
: backup_table_id_(common::OB_INVALID_ID),
backup_index_id_(common::OB_INVALID_ID),
backup_tablegroup_id_(common::OB_INVALID_ID),
backup_table_name_(),
backup_index_name_(),
backup_tablegroup_name_(),
backup_database_name_()
{
MEMSET(backup_table_name_buf_, 0, common::OB_MAX_TABLE_NAME_BUF_LENGTH);
MEMSET(backup_database_name_buf_, 0, common::OB_MAX_DATABASE_NAME_BUF_LENGTH);
MEMSET(backup_index_name_buf_, 0, common::OB_MAX_TABLE_NAME_BUF_LENGTH);
MEMSET(backup_tablegroup_name_buf_, 0, common::OB_MAX_TABLEGROUP_NAME_LENGTH);
}
void set_backup_table_id(const uint64_t table_id)
{
backup_table_id_ = table_id;
}
void set_backup_index_id(const uint64_t table_id)
{
backup_index_id_ = table_id;
}
void set_backup_tablegroup_id(const uint64_t tablegroup_id)
{
backup_tablegroup_id_ = tablegroup_id;
}
int set_backup_table_name(const common::ObString &tb_name)
{
common::ObDataBuffer allocator(backup_table_name_buf_, common::OB_MAX_TABLE_NAME_BUF_LENGTH);
return ob_write_string(allocator, tb_name, backup_table_name_);
}
int set_backup_index_name(const common::ObString &tb_name)
{
common::ObDataBuffer allocator(backup_index_name_buf_, common::OB_MAX_TABLE_NAME_BUF_LENGTH);
return ob_write_string(allocator, tb_name, backup_index_name_);
}
int add_backup_index_name_prefix(const uint64_t table_id)
{
int ret = common::OB_SUCCESS;
if (backup_index_name_.prefix_match(common::OB_MYSQL_RECYCLE_PREFIX)
|| backup_index_name_.prefix_match(common::OB_ORACLE_RECYCLE_PREFIX)) {
// do nothing
} else {
char tmp_buf[common::OB_MAX_TABLE_NAME_LENGTH];
int pos = snprintf(tmp_buf,
common::OB_MAX_TABLE_NAME_LENGTH, "%s%lu_%.*s",
common::OB_INDEX_PREFIX,
table_id,
backup_index_name_.length(), backup_index_name_.ptr());
if (pos < 0 || pos >= common::OB_MAX_TABLE_NAME_LENGTH) {
ret = common::OB_BUF_NOT_ENOUGH;
} else {
MEMCPY(backup_index_name_buf_, tmp_buf, pos);
backup_index_name_.assign(backup_index_name_buf_, pos);
}
}
return ret;
}
int set_backup_db_name(const common::ObString &db_name)
{
common::ObDataBuffer allocator(backup_database_name_buf_, common::OB_MAX_DATABASE_NAME_BUF_LENGTH);
return ob_write_string(allocator, db_name, backup_database_name_);
}
int set_backup_tablegroup_name(const common::ObString &tg_name)
{
common::ObDataBuffer allocator(backup_tablegroup_name_buf_, common::OB_MAX_TABLEGROUP_NAME_LENGTH);
return ob_write_string(allocator, tg_name, backup_tablegroup_name_);
}
uint64_t backup_table_id_;
uint64_t backup_index_id_;
uint64_t backup_tablegroup_id_;
common::ObString backup_table_name_;
common::ObString backup_index_name_;
common::ObString backup_tablegroup_name_;
common::ObString backup_database_name_;
// buffer
char backup_table_name_buf_[common::OB_MAX_TABLE_NAME_BUF_LENGTH];
char backup_index_name_buf_[common::OB_MAX_TABLE_NAME_BUF_LENGTH];
char backup_tablegroup_name_buf_[common::OB_MAX_TABLEGROUP_NAME_LENGTH];
char backup_database_name_buf_[common::OB_MAX_DATABASE_NAME_BUF_LENGTH];
TO_STRING_KV(K_(backup_table_id),
K_(backup_index_id),
K_(backup_tablegroup_id),
K_(backup_table_name),
K_(backup_index_name),
K_(backup_database_name),
K_(backup_tablegroup_name));
};
public:
static constexpr int64_t OB_MAX_URI_LENGTH = 2048;
static constexpr int64_t OB_MAX_URI_HOST_LENGTH = 128;
static constexpr int64_t OB_MAX_URI_ACCESS_ID_LENGTH = 128;
static constexpr int64_t OB_MAX_URI_ACCESS_KEY_LENGTH = 128;
static constexpr int64_t OB_MAX_URI_PROTOCOL_LENGTH = 16;
static constexpr int64_t OB_MAX_URI_BUCKET_LENGTH = 512;
static constexpr int64_t OB_MAX_CLUSTER_NAME_LENGTH = 128;
static constexpr int64_t OB_MAX_POOL_LIST_LENGTH = 256;
static constexpr int64_t OB_MAX_URI_BUCKET_DIR_DEPTH = 10;
static constexpr int64_t OB_MAX_TCP_INVITED_NODES_LENGTH = common::MAX_IP_ADDR_LENGTH * 100;//3,200
public:
ObRestoreArgs();
~ObRestoreArgs() = default;
void reset();
bool is_valid() const;
bool is_parse_ok() const;
bool is_inplace_restore() const;
int set_schema_id_pairs(const common::ObIArray<ObSchemaIdPair> &pairs);
int trans_to_backup_schema_id(const uint64_t schema_id, uint64_t &backup_schema_id) const;
int trans_from_backup_schema_id(const uint64_t backup_schema_id, uint64_t &schema_id) const;
const char *get_uri_header() const;
const char *get_cluster_name() const;
const char *get_storage_info() const;
// oss://071092/obfin001/1001?host=xxxx&access_id=xxx&&access_key=xxx&timestamp=xxxx&restore_user=xxx&restore_pass=xxx
char uri_header_[common::OB_MAX_URI_HEADER_LENGTH];//oss://071092
char cluster_name_[common::OB_MAX_CLUSTER_NAME_LENGTH];//obfin001
char storage_info_[common::OB_MAX_URI_LENGTH];
char primary_zone_[common::MAX_ZONE_LENGTH];
char locality_[common::MAX_LOCALITY_LENGTH];
char pool_list_[OB_MAX_POOL_LIST_LENGTH];
char restore_user_[common::OB_MAX_USERNAME_LENGTH];
char restore_pass_[common::OB_MAX_PASSWORD_LENGTH];
char tcp_invited_nodes_[OB_MAX_TCP_INVITED_NODES_LENGTH];
int64_t base_data_version_; // 32
int64_t curr_data_version_; // 33
int64_t tenant_id_; // 1001
int64_t restore_timeu_; // timestamp xxxx
uint64_t backup_schema_id_; // tablegroup_id or table_id
int64_t partition_id_;
//Above RS: In the case of pg, it contains the id pair of the main table and the index table; in the case of a standalone partition, it only contains the id pair of the index table
//STORAGE above: tandalone partition, including the id pair of the main table and the index table
common::ObSEArray<ObSchemaIdPair, 1> schema_id_list_;
OrignalSQLInfo sql_info_; // Some information in the original SQL, such as original table_id, etc.
int64_t schema_version_;
uint64_t cluster_version_; // Backup cluster version number
ObSchemaIdPair schema_id_pair_; // tablegroup_id:backup_tablegroup_id or table_id:backup_table_id
;
TO_STRING_KV(K(tenant_id_),
K_(locality),
K_(primary_zone),
K_(pool_list),
K_(tcp_invited_nodes),
K_(base_data_version),
K_(curr_data_version),
K_(tenant_id),
K_(restore_timeu),
K_(backup_schema_id),
K_(partition_id),
K_(schema_id_list),
K_(sql_info),
K_(schema_version),
K_(uri_header),
K_(cluster_name),
K_(storage_info),
K_(schema_id_list));
private:
/* functions */
int add_schema_id_pair(const uint64_t schema_id, const uint64_t backup_schema_id);
/* variables */
};
}
}
#endif /* __OB_SHARE_RESTORE_OB_RESTORE_ARGS_H__ */
//// end of header file

1
src/share/restore/ob_restore_uri_parser.h
View File

@ -16,7 +16,6 @@
#include "share/restore/ob_physical_restore_info.h"
#include "share/ob_kv_parser.h"
#include "share/ob_list_parser.h"
#include "share/restore/ob_restore_args.h"
#include "lib/hash/ob_hashmap.h"
#include "common/ob_zone.h"

3
src/share/schema/ob_schema_retrieve_utils.ipp
View File

@ -2688,9 +2688,6 @@ int ObSchemaRetrieveUtils::retrieve_system_variable_obj(
SHARE_SCHEMA_LOG(WARN,"fail to extract data", K(ret));
} else if (is_deleted) {
ret = common::OB_ENTRY_NOT_EXIST;
} else if (OB_UNLIKELY(result_value.length() > common::OB_MAX_SYS_VAR_VAL_LENGTH)) {
ret = OB_SIZE_OVERFLOW;
SHARE_SCHEMA_LOG(WARN, "set sysvar value is overflow", "max length", OB_MAX_SYS_VAR_VAL_LENGTH, "value length", result_value.length());
} else if (!result_value.empty() && OB_ISNULL(value_buf = static_cast<char*>(allocator.alloc(result_value.length())))) {
ret = common::OB_ALLOCATE_MEMORY_FAILED;
SHARE_SCHEMA_LOG(WARN,"fail to alloc char array", K(ret));

13
src/sql/engine/cmd/ob_tenant_executor.cpp
View File

@ -379,9 +379,18 @@ int check_sys_var_options(ObExecContext &ctx,
EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE);
EXPR_GET_VARCHAR_V2(value_obj, val_str);
if (OB_SUCC(ret)) {
if(OB_UNLIKELY(val_str.length() > OB_MAX_SYS_VAR_VAL_LENGTH)) {
int64_t sys_var_val_length = OB_MAX_SYS_VAR_VAL_LENGTH;
if (set_var.var_name_ == OB_SV_TCP_INVITED_NODES) {
uint64_t data_version = 0;
if (OB_FAIL(GET_MIN_DATA_VERSION(set_var.actual_tenant_id_, data_version))) {
LOG_WARN("fail to get sys data version", KR(ret));
} else if (data_version >= DATA_VERSION_4_2_1_1) {
sys_var_val_length = OB_MAX_TCP_INVITED_NODES_LENGTH;
}
}
if (OB_SUCC(ret) && OB_UNLIKELY(val_str.length() > sys_var_val_length)) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("set sysvar value is overflow", "max length", OB_MAX_SYS_VAR_VAL_LENGTH, "value length", val_str.length(), K(sys_id), K(val_str));
LOG_WARN("set sysvar value is overflow", "max length", sys_var_val_length, "value length", val_str.length(), K(sys_id), K(val_str));
} else if (OB_FAIL(sys_var_list.push_back(obrpc::ObSysVarIdValue(sys_id, val_str)))) {
LOG_WARN("failed to push back", K(sys_id), K(val_str), K(ret));
}

14
src/sql/engine/cmd/ob_variable_set_executor.cpp
View File

@ -715,9 +715,19 @@ int ObVariableSetExecutor::update_global_variables(ObExecContext &ctx,
EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE);
EXPR_GET_VARCHAR_V2(val, val_str);
ObSysVarSchema sysvar_schema;
if (OB_UNLIKELY(val_str.length() > OB_MAX_SYS_VAR_VAL_LENGTH)) {
int64_t sys_var_val_length = OB_MAX_SYS_VAR_VAL_LENGTH;
if (set_var.var_name_ == OB_SV_TCP_INVITED_NODES) {
uint64_t data_version = 0;
if (OB_FAIL(GET_MIN_DATA_VERSION(set_var.actual_tenant_id_, data_version))) {
LOG_WARN("fail to get sys data version", KR(ret));
} else if (data_version >= DATA_VERSION_4_2_1_1) {
sys_var_val_length = OB_MAX_TCP_INVITED_NODES_LENGTH;
}
}
if (OB_SUCC(ret) && OB_UNLIKELY(val_str.length() > sys_var_val_length)) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("set sysvar value is overflow", "max length", OB_MAX_SYS_VAR_VAL_LENGTH,
LOG_WARN("set sysvar value is overflow", "max length", sys_var_val_length,
"value length", val_str.length(), "name", set_var.var_name_, "value", val_str);
} else if (OB_FAIL(sysvar_schema.set_name(set_var.var_name_))) {
LOG_WARN("set sysvar schema name failed", K(ret));

15
src/sql/engine/expr/ob_expr_get_sys_var.cpp
View File

@ -79,7 +79,19 @@ int ObExprGetSysVar::calc_result_type2(ObExprResType &type,
}
if (ob_is_string_type(data_type)) {
type.set_collation_level(CS_LEVEL_SYSCONST);
type.set_length(OB_MAX_SYS_VAR_VAL_LENGTH);
int64_t sys_var_val_length = OB_MAX_SYS_VAR_VAL_LENGTH;
if (0 == var_name.compare(OB_SV_TCP_INVITED_NODES)) {
uint64_t data_version = 0;
if (OB_FAIL(GET_MIN_DATA_VERSION(session->get_effective_tenant_id(), data_version))) {
LOG_WARN("fail to get sys data version", KR(ret));
} else if (data_version >= DATA_VERSION_4_2_1_1) {
sys_var_val_length = OB_MAX_TCP_INVITED_NODES_LENGTH;
}
}
if (OB_SUCC(ret)) {
type.set_length(sys_var_val_length);
if (is_oracle_mode()) {
type.set_collation_type(session->get_nls_collation());
type.set_length_semantics(session->get_actual_nls_length_semantics());
@ -90,6 +102,7 @@ int ObExprGetSysVar::calc_result_type2(ObExprResType &type,
}
}
}
}
} else {
ret = OB_ERR_SYS_VARIABLE_UNKNOWN;
LOG_USER_ERROR(OB_ERR_SYS_VARIABLE_UNKNOWN, var_name.length(), var_name.ptr());

17
src/sql/resolver/ddl/ob_create_tenant_stmt.cpp
View File

@ -123,23 +123,6 @@ int ObCreateTenantStmt::set_default_tablegroup_name(const common::ObString &tabl
return create_tenant_arg_.tenant_schema_.set_default_tablegroup_name(tablegroup_name);
}
int ObCreateTenantStmt::set_tcp_invited_nodes(common::ObString value)
{
int ret = OB_SUCCESS;
const share::ObSysVarClassType sys_id = share::SYS_VAR_OB_TCP_INVITED_NODES;
if (value.empty()) {
//if not set it, or set it null, use ALLOW_ALL police
value = common::ObString::make_string("%");
}
if(OB_UNLIKELY(value.length() > OB_MAX_SYS_VAR_VAL_LENGTH)) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("set sysvar value is overflow", "max length", OB_MAX_SYS_VAR_VAL_LENGTH, "value length", value.length(), K(sys_id), K(value));
} else if (OB_FAIL(create_tenant_arg_.sys_var_list_.push_back(obrpc::ObSysVarIdValue(sys_id, value)))) {
LOG_WARN("failed to push back", K(sys_id), K(value), K(ret));
}
return ret;
}
void ObCreateTenantStmt::set_create_standby_tenant()
{
create_tenant_arg_.is_creating_standby_ = true;

1
src/sql/resolver/ddl/ob_create_tenant_stmt.h
View File

@ -37,7 +37,6 @@ public:
int add_zone(const common::ObString &zone);
int set_comment(const common::ObString &commont);
int set_locality(const common::ObString &locality);
int set_tcp_invited_nodes(common::ObString value);
void set_primary_zone(const common::ObString &zone);
void set_if_not_exist(const bool is_exist);
void set_charset_type(const common::ObCharsetType type);

1
unittest/share/CMakeLists.txt
View File

@ -22,7 +22,6 @@ storage_unittest(test_dag_scheduler scheduler/test_dag_scheduler.cpp)
storage_unittest(test_dag_net_in_dag_scheduler scheduler/test_dag_net_in_dag_scheduler.cpp)
#ob_unittest(test_web_service_root_addr)
#ob_unittest(test_web_service_root_addr2)
#ob_unittest(test_restore_uri_parser)
#ob_unittest(test_kv_storecache)
#ob_unittest(test_async_task_queue)
#ob_unittest(test_dml_sql_splicer)

186
unittest/share/test_restore_uri_parser.cpp
View File

@ -1,186 +0,0 @@
/**
* 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 SHARE
#include <gtest/gtest.h>
#include "lib/utility/ob_test_util.h"
#include "share/restore/ob_restore_uri_parser.h"
#include "vsclient.h"
#include "aos_define.h"
#include "aos_http_io.h"
using namespace oceanbase::common;
using namespace oceanbase::share;
class TestRestoreURIParser: public ::testing::Test
{
public:
TestRestoreURIParser();
virtual ~TestRestoreURIParser();
virtual void SetUp();
virtual void TearDown();
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(TestRestoreURIParser);
protected:
// function members
protected:
// data members
};
TestRestoreURIParser::TestRestoreURIParser()
{
int ret = OB_SUCCESS;
int aos_ret = AOSE_OK;
if(AOSE_OK != (aos_ret = aos_http_io_initialize(NULL, 0))) {
OB_LOG(WARN, "fail to init aos", K(aos_ret));
}
VIPSrv_Result *result = NULL;
VIPSrv_Config config;
config.jmenv_dom = "jmenv.tbsite.net";
config.cache_dir = getenv("HOME");
if(NULL == (result = vipsrv_global_init(&config))) {
ret = OB_OSS_ERROR;
OB_LOG(WARN, "fail to init vipserver", K(ret));
} else if(!result->is_success) {
ret = OB_OSS_ERROR;
OB_LOG(WARN, "fail to init vipserver", K(ret));
}
if(NULL != result) {
vipsrv_result_deref(result);
}
}
TestRestoreURIParser::~TestRestoreURIParser()
{
vipsrv_global_cleanup();
aos_http_io_deinitialize();
}
void TestRestoreURIParser::SetUp()
{
}
void TestRestoreURIParser::TearDown()
{
}
TEST_F(TestRestoreURIParser, test_basic)
{
ObRestoreArgs arg;
const char *uri_001 = "oss://071092/ob2.haipeng.zhp/1001?timestamp=1495444477922616&host=xxx.com&access_id=111&access_key=222&restore_user=a&restore_pass=b";
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
}
TEST_F(TestRestoreURIParser, test_long_bucket)
{
ObRestoreArgs arg;
const char *uri_001 = "oss://071092/test_ob1/1.323/ob2.haipeng.zhp/1001?timestamp=1495444477922616&host=xxx.com&access_id=111&access_key=222&restore_user=a&restore_pass=b";
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
LOG_INFO("long bucket", K(arg));
}
TEST_F(TestRestoreURIParser, test_more)
{
ObRestoreArgs arg;
const char *uri_001 = "file:///071092/ob2.haipeng.zhp/1001?timestamp=1495444477922616&host=xxx.com&access_id=111&access_key=222&restore_user=a&restore_pass=b";
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
LOG_INFO("tset more", K(arg));
ASSERT_TRUE(0 == strcmp(arg.storage_info_, "timestamp=1495444477922616&host=xxx.com&access_id=111&access_key=222&restore_user=a&restore_pass=b"));
ASSERT_TRUE(1001 == arg.tenant_id_);
ASSERT_TRUE(0 == strcmp(arg.uri_, "file:///071092/ob2.haipeng.zhp"));
ASSERT_TRUE(1495444477922616 == arg.restore_timeu_);
}
TEST_F(TestRestoreURIParser, testBlankExtraParam)
{
ObRestoreArgs arg;
const char *uri_000 = "oss://bucket/appname /1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_001 = "oss://bucket/app name/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_002 = "oss://bucket/appname/1001?timestamp =10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_003 = "oss://bucket/appname/1001?timestamp=10 &host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_004 = "oss://bucket/appname/1001? timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_005 = "oss://bucket/appname/1001? timestamp=10&host=host_001&access_id=id_001&access_key=key_001";
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_000), arg));
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_002), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_003), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_004), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_005), arg));
}
TEST_F(TestRestoreURIParser, idIsNotInt)
{
ObRestoreArgs arg;
const char *uri_001 = "oss://bucket/appname/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_002 = "oss://bucket/appname/1001BadTenant?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_003 = "oss://bucket/appname/1001BadTenant?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_004 = "oss://bucket/appname/1001?timestamp=badTs0&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_002), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_003), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_004), arg));
}
TEST_F(TestRestoreURIParser, anyProtocol)
{
ObRestoreArgs arg;
const char *uri_001 = "os://bucket/appname/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_002 = "oss?//bucket/appname/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_003 = "oss///bucket/appname/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_004 = "bucket/appname/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_005 = "file:///appname/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
ASSERT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_002), arg)); // oss? <= sep
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_003), arg));
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_004), arg));
ASSERT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_005), arg));
}
TEST_F(TestRestoreURIParser, valueTooLong)
{
ObRestoreArgs arg;
char uri_001[4096];
snprintf(uri_001, 4096, "oss://%03000d/appname/11/1001?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b", 1);
ASSERT_EQ(OB_SIZE_OVERFLOW, ObRestoreURIParser::parse(ObString(uri_001), arg));
LOG_INFO("too long bucket", K(uri_001));
}
TEST_F(TestRestoreURIParser, LessOrMoreDir)
{
ObRestoreArgs arg;
const char *uri_002 = "oss://bucket/appname/11/111/123?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_003 = "oss://bucket/appname?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
const char *uri_004 = "oss://?timestamp=10&host=host_001&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
EXPECT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_002), arg));
EXPECT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_003), arg));
EXPECT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParser::parse(ObString(uri_004), arg));
}
TEST_F(TestRestoreURIParser, ConflictVersionTimestamp)
{
ObRestoreArgs arg;
const char *uri_001 = "oss://bucket/appname/11/1001?timestamp=123123123&access_id=id_001&access_key=key_001&restore_user=a&restore_pass=b";
EXPECT_EQ(OB_SUCCESS, ObRestoreURIParser::parse(ObString(uri_001), arg));
EXPECT_EQ(OB_INVALID_ARGUMENT, ObRestoreURIParserHelper::set_data_version(arg));
}
int main(int argc, char **argv)
{
//oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
OB_LOGGER.set_log_level("INFO", "WARN");
// OB_LOGGER.set_mod_log_levels("ALL.*:INFO,LIB.MYSQLC:ERROR");
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}