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

[to #56938636] support PLSQL_OPTIMIZE_LEVEL and _ob_pl_compile_max_concurrency

Browse Source
This commit is contained in:
0xacc 2024-05-28 07:16:01 +00:00 committed by ob-robot
parent cf5ea56653
commit 585fc4901c
18 changed files with 199 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/objit/include/objit/ob_llvm_helper.h
View File

@ -43,6 +43,7 @@ namespace oceanbase
{
namespace jit
{
enum class ObPLOptLevel : int;
namespace core {
class JitContext;
@ -360,7 +361,7 @@ public:
int init();
void final();
static int initialize();
void compile_module(bool optimization = true);
int compile_module(jit::ObPLOptLevel optimization);
void dump_module();
void dump_debuginfo();
int verify_function(ObLLVMFunction &function);

22
src/objit/src/core/ob_orc_jit.cpp
View File

@ -178,6 +178,28 @@ void ObOrcJit::add_compiled_object(size_t length, const char *ptr)
ObModuleKeys.push_back(Key);
}
int ObOrcJit::set_optimize_level(ObPLOptLevel level)
{
int ret = OB_SUCCESS;
if (level <= ObPLOptLevel::INVALID || level > ObPLOptLevel::O3) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected PLSQL_OPTIMIZE_LEVEL", K(ret), K(level), K(lbt()));
}
if (OB_SUCC(ret) && OB_ISNULL(ObTM)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL TM", K(ret), K(ObTM.get()), K(lbt()));
}
if (OB_SUCC(ret) && level == ObPLOptLevel::O0) {
ObTM->setOptLevel(CodeGenOpt::Level::None);
ObTM->setFastISel(true);
}
return ret;
}
} // namespace core
} // objit
} // oceanbase

12
src/objit/src/core/ob_orc_jit.h
View File

@ -31,6 +31,16 @@
namespace oceanbase {
namespace jit {
enum class ObPLOptLevel : int
{
INVALID = -1,
O0 = 0,
O1 = 1,
O2 = 2,
O3 = 3
};
namespace core {
using namespace llvm;
@ -85,6 +95,8 @@ public:
const ObString& get_compiled_object() const { return SoObject; }
int set_optimize_level(ObPLOptLevel level);
private:
std::string mangle(const std::string &Name)
{

26
src/objit/src/ob_llvm_helper.cpp
View File

@ -597,22 +597,30 @@ int ObLLVMHelper::init_llvm() {
OZ (helper.get_int64(OB_SUCCESS, magic));
OZ (helper.create_ret(magic));
OX (helper.compile_module());
OZ (helper.compile_module(jit::ObPLOptLevel::O2));
OX (helper.get_function_address(init_func_name));
return ret;
}
void ObLLVMHelper::compile_module(bool optimization)
int ObLLVMHelper::compile_module(jit::ObPLOptLevel optimization)
{
if (optimization) {
OB_LLVM_MALLOC_GUARD(GET_PL_MOD_STRING(pl::OB_PL_CODE_GEN));
jc_->optimize();
LOG_INFO("================Optimized LLVM Module================");
dump_module();
int ret = OB_SUCCESS;
if (OB_FAIL(jit_->set_optimize_level(optimization))) {
LOG_WARN("failed to set backend optimize level", K(ret), K(optimization));
} else {
if (optimization >= jit::ObPLOptLevel::O2) {
OB_LLVM_MALLOC_GUARD(GET_PL_MOD_STRING(pl::OB_PL_CODE_GEN));
jc_->optimize();
LOG_INFO("================Optimized LLVM Module================");
dump_module();
}
OB_LLVM_MALLOC_GUARD(GET_PL_MOD_STRING(pl::OB_PL_JIT));
jc_->compile();
}
OB_LLVM_MALLOC_GUARD(GET_PL_MOD_STRING(pl::OB_PL_JIT));
jc_->compile();
return ret;
}
void ObLLVMHelper::dump_module()

3
src/pl/ob_pl.cpp
View File

@ -188,7 +188,8 @@ int ObPL::init(common::ObMySQLProxy &sql_proxy)
sql_proxy_ = &sql_proxy;
OZ (codegen_lock_.init(1024));
OZ (jit_lock_.init(32));
OZ (jit_lock_.first.init(1024));
OZ (jit_lock_.second.init(1024));
OZ (interface_service_.init());
OX (serialize_composite_callback = ObUserDefinedType::serialize_obj);
OX (deserialize_composite_callback = ObUserDefinedType::deserialize_obj);

6
src/pl/ob_pl.h
View File

@ -1192,7 +1192,7 @@ public:
static int check_trigger_arg(const ParamStore &params, const ObPLFunction &func);
ObBucketLock& get_jit_lock() { return jit_lock_; }
std::pair<common::ObBucketLock, common::ObBucketLock>& get_jit_lock() { return jit_lock_; }
static int check_session_alive(const ObBasicSessionInfo &session);
@ -1201,7 +1201,9 @@ private:
ObPLPackageManager package_manager_;
ObPLInterfaceService interface_service_;
common::ObBucketLock codegen_lock_;
common::ObBucketLock jit_lock_;
// first bucket is for deduplication, second bucket is for concurrency control
std::pair<common::ObBucketLock, common::ObBucketLock> jit_lock_;
};
class LinkPLStackGuard

12
src/pl/ob_pl_code_generator.cpp
View File

@ -8301,8 +8301,12 @@ int ObPLCodeGenerator::generate(ObPLPackage &pl_package)
LOG_INFO("================Original LLVM Module================", K(debug_mode_));
helper_.dump_module();
#endif
// set optimize_level to 0 if in debug mode, otherwise use PLSQL_OPTIMIZE_LEVEL in exec_env
int64_t optimize_level = debug_mode_ ? 0 : pl_package.get_exec_env().get_plsql_optimize_level();
OZ (helper_.verify_module(), pl_package);
OX (helper_.compile_module(!debug_mode_));
OZ (helper_.compile_module(static_cast<jit::ObPLOptLevel>(optimize_level)));
}
OZ (final_expression(pl_package));
@ -8446,8 +8450,12 @@ int ObPLCodeGenerator::generate_normal(ObPLFunction &pl_func)
LOG_INFO("================Original================", K(pl_func), K(debug_mode_));
helper_.dump_module();
#endif
// set optimize_level to 0 if in debug mode, otherwise use PLSQL_OPTIMIZE_LEVEL in exec_env
int64_t optimize_level = debug_mode_ ? 0 : pl_func.get_exec_env().get_plsql_optimize_level();
OZ (helper_.verify_module(), pl_func);
OX (helper_.compile_module(!debug_mode_));
OZ (helper_.compile_module(static_cast<jit::ObPLOptLevel>(optimize_level)));
}
if (OB_SUCC(ret)) {

26
src/pl/ob_pl_compile.cpp
View File

@ -233,7 +233,11 @@ int ObPLCompiler::compile(
#endif
lib::ObMallocHookAttrGuard malloc_guard(lib::ObMemAttr(MTL_ID(), GET_PL_MOD_STRING(pl::OB_PL_CODE_GEN)));
uint64_t lock_idx = stmt_id != OB_INVALID_ID ? stmt_id : murmurhash(block->str_value_, block->str_len_, 0);
ObBucketHashWLockGuard compile_guard(GCTX.pl_engine_->get_jit_lock(), lock_idx);
// latch_id = (bucket_id % bucket_cnt_) / 8, so it is needed to multiply 8 to avoid consecutive ids being mapped to the same latch
ObBucketHashWLockGuard compile_id_guard(GCTX.pl_engine_->get_jit_lock().first, lock_idx * 8);
ObBucketHashWLockGuard compile_num_guard(GCTX.pl_engine_->get_jit_lock().second, (lock_idx % GCONF._ob_pl_compile_max_concurrency) * 8);
// check session status after get lock
if (OB_FAIL(ObPL::check_session_alive(session_info_))) {
LOG_WARN("query or session is killed after get PL jit lock", K(ret));
@ -476,7 +480,9 @@ int ObPLCompiler::compile(
OZ (cg.init());
OZ (read_dll_from_disk(enable_persistent, routine_storage, func_ast, cg, routine, func, op));
if (OB_SUCC(ret) && 0 == func.get_action()) { // not in disk
ObBucketHashWLockGuard compile_guard(GCTX.pl_engine_->get_jit_lock(), routine.get_routine_id());
// latch_id = (bucket_id % bucket_cnt_) / 8, so it is needed to multiply 8 to avoid consecutive ids being mapped to the same latch
ObBucketHashWLockGuard compile_id_guard(GCTX.pl_engine_->get_jit_lock().first, routine.get_routine_id() * 8);
ObBucketHashWLockGuard compile_num_guard(GCTX.pl_engine_->get_jit_lock().second, (routine.get_routine_id() % GCONF._ob_pl_compile_max_concurrency) * 8);
OZ (ObPL::check_session_alive(session_info_));
OZ (read_dll_from_disk(enable_persistent, routine_storage, func_ast, cg, routine, func, op)); // has lock, try read dll again
if (OB_SUCC(ret) && 0 == func.get_action()) { // nobody code gen yet! do real code generate
@ -740,7 +746,10 @@ int ObPLCompiler::generate_package(const ObString &exec_env, ObPLPackageAST &pac
if (op == ObRoutinePersistentInfo::ObPLOperation::SUCC) {
//do nothing
} else {
ObBucketHashWLockGuard compile_guard(GCTX.pl_engine_->get_jit_lock(), package.get_id());
// latch_id = (bucket_id % bucket_cnt_) / 8, so it is needed to multiply 8 to avoid consecutive ids being mapped to the same latch
ObBucketHashWLockGuard compile_id_guard(GCTX.pl_engine_->get_jit_lock().first, package.get_id() * 8);
ObBucketHashWLockGuard compile_num_guard(GCTX.pl_engine_->get_jit_lock().second, (package.get_id() % GCONF._ob_pl_compile_max_concurrency) * 8);
OZ (ObPL::check_session_alive(session_info_));
if (OB_SUCC(ret)) {
if (need_read_dll) {
@ -815,11 +824,6 @@ int ObPLCompiler::compile_package(const ObPackageInfo &package_info,
package_ast, package_info.is_for_trigger()));
{
// check session status after get lock
if (OB_SUCC(ret) && OB_FAIL(ObPL::check_session_alive(session_info_))) {
LOG_WARN("query or session is killed after get PL jit lock", K(ret));
}
if (OB_SUCC(ret)) {
#ifdef USE_MCJIT
HEAP_VAR(ObPLCodeGenerator, cg ,allocator_, session_info_) {
@ -834,7 +838,11 @@ int ObPLCompiler::compile_package(const ObPackageInfo &package_info,
lib::is_oracle_mode()) {
#endif
lib::ObMallocHookAttrGuard malloc_guard(lib::ObMemAttr(MTL_ID(), GET_PL_MOD_STRING(pl::OB_PL_CODE_GEN)));
ObBucketHashWLockGuard compile_guard(GCTX.pl_engine_->get_jit_lock(), package.get_id());
// latch_id = (bucket_id % bucket_cnt_) / 8, so it is needed to multiply 8 to avoid consecutive ids being mapped to the same latch
ObBucketHashWLockGuard compile_id_guard(GCTX.pl_engine_->get_jit_lock().first, package.get_id() * 8);
ObBucketHashWLockGuard compile_num_guard(GCTX.pl_engine_->get_jit_lock().second, (package.get_id() % GCONF._ob_pl_compile_max_concurrency) * 8);
// check session status after get lock
OZ (ObPL::check_session_alive(session_info_));

11
src/share/parameter/ob_parameter_seed.ipp
View File

@ -1302,11 +1302,6 @@ DEF_STR(plsql_code_type, OB_TENANT_PARAMETER, "native",
DEF_BOOL(plsql_debug, OB_TENANT_PARAMETER, "False",
"specifies whether or not PL/SQL library units will be compiled for debugging",
ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
DEF_INT(plsql_optimize_level, OB_TENANT_PARAMETER, "1",
"specifies the optimization level that will be used to"
"compile PL/SQL library units. The higher the setting of this parameter, the more effort"
"the compiler makes to optimize PL/SQL library units",
ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
DEF_BOOL(plsql_v2_compatibility, OB_TENANT_PARAMETER, "False",
"allows some abnormal behavior that Version 8 disallows, not available",
ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
@ -1965,4 +1960,8 @@ DEF_BOOL(_enable_dbms_job_package, OB_CLUSTER_PARAMETER, "True",
// obkv feature switch
DEF_BOOL(_enable_kv_feature, OB_CLUSTER_PARAMETER, "True",
"Enable or disable OBKV feature.",
ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
DEF_INT(_ob_pl_compile_max_concurrency, OB_CLUSTER_PARAMETER, "4", "[0,)",
"The maximum number of threads that an observer node can compile PL concurrently.",
ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));

1
src/share/system_variable/ob_sys_var_class_type.h
View File

@ -438,6 +438,7 @@ enum ObSysVarClassType
SYS_VAR_INNODB_AUTOINC_LOCK_MODE = 10389,
SYS_VAR_SKIP_EXTERNAL_LOCKING = 10390,
SYS_VAR_SUPER_READ_ONLY = 10391,
SYS_VAR_PLSQL_OPTIMIZE_LEVEL = 10393,
};
}

1
src/share/system_variable/ob_system_variable_alias.h
View File

@ -433,6 +433,7 @@ namespace share
static const char* const OB_SV_INNODB_AUTOINC_LOCK_MODE = "innodb_autoinc_lock_mode";
static const char* const OB_SV_SKIP_EXTERNAL_LOCKING = "skip_external_locking";
static const char* const OB_SV_SUPER_READ_ONLY = "super_read_only";
static const char* const OB_SV_PLSQL_OPTIMIZE_LEVEL = "plsql_optimize_level";
}
}

26
src/share/system_variable/ob_system_variable_factory.cpp
View File

@ -705,6 +705,7 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_NAME[] = {
"parallel_servers_target",
"performance_schema",
"plsql_ccflags",
"plsql_optimize_level",
"plsql_warnings",
"plugin_dir",
"privilege_features_enable",
@ -1125,6 +1126,7 @@ const ObSysVarClassType ObSysVarFactory::SYS_VAR_IDS_SORTED_BY_NAME[] = {
SYS_VAR_PARALLEL_SERVERS_TARGET,
SYS_VAR_PERFORMANCE_SCHEMA,
SYS_VAR_PLSQL_CCFLAGS,
SYS_VAR_PLSQL_OPTIMIZE_LEVEL,
SYS_VAR_PLSQL_WARNINGS,
SYS_VAR_PLUGIN_DIR,
SYS_VAR_PRIVILEGE_FEATURES_ENABLE,
@ -1659,7 +1661,8 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_ID[] = {
"innodb_api_disable_rowlock",
"innodb_autoinc_lock_mode",
"skip_external_locking",
"super_read_only"
"super_read_only",
"plsql_optimize_level"
};
bool ObSysVarFactory::sys_var_name_case_cmp(const char *name1, const ObString &name2)
@ -2245,6 +2248,7 @@ int ObSysVarFactory::create_all_sys_vars()
+ sizeof(ObSysVarInnodbAutoincLockMode)
+ sizeof(ObSysVarSkipExternalLocking)
+ sizeof(ObSysVarSuperReadOnly)
+ sizeof(ObSysVarPlsqlOptimizeLevel)
;
void *ptr = NULL;
if (OB_ISNULL(ptr = allocator_.alloc(total_mem_size))) {
@ -6006,6 +6010,15 @@ int ObSysVarFactory::create_all_sys_vars()
ptr = (void *)((char *)ptr + sizeof(ObSysVarSuperReadOnly));
}
}
if (OB_SUCC(ret)) {
if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarPlsqlOptimizeLevel())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("fail to new ObSysVarPlsqlOptimizeLevel", K(ret));
} else {
store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast<int64_t>(SYS_VAR_PLSQL_OPTIMIZE_LEVEL))] = sys_var_ptr;
ptr = (void *)((char *)ptr + sizeof(ObSysVarPlsqlOptimizeLevel));
}
}
}
return ret;
@ -10603,6 +10616,17 @@ int ObSysVarFactory::create_sys_var(ObIAllocator &allocator_, ObSysVarClassType
}
break;
}
case SYS_VAR_PLSQL_OPTIMIZE_LEVEL: {
void *ptr = NULL;
if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarPlsqlOptimizeLevel)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarPlsqlOptimizeLevel)));
} else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarPlsqlOptimizeLevel())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("fail to new ObSysVarPlsqlOptimizeLevel", K(ret));
}
break;
}
default: {
ret = OB_ERR_UNEXPECTED;

9
src/share/system_variable/ob_system_variable_factory.h
View File

@ -3072,6 +3072,13 @@ public:
inline virtual ObSysVarClassType get_type() const { return SYS_VAR_SUPER_READ_ONLY; }
inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(416); }
};
class ObSysVarPlsqlOptimizeLevel : public ObIntSysVar
{
public:
ObSysVarPlsqlOptimizeLevel() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {}
inline virtual ObSysVarClassType get_type() const { return SYS_VAR_PLSQL_OPTIMIZE_LEVEL; }
inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(417); }
};
class ObSysVarFactory
@ -3092,7 +3099,7 @@ public:
static const common::ObString get_sys_var_name_by_id(ObSysVarClassType sys_var_id);
const static int64_t MYSQL_SYS_VARS_COUNT = 99;
const static int64_t OB_SYS_VARS_COUNT = 318;
const static int64_t OB_SYS_VARS_COUNT = 319;
const static int64_t ALL_SYS_VARS_COUNT = MYSQL_SYS_VARS_COUNT + OB_SYS_VARS_COUNT;
const static int64_t INVALID_MAX_READ_STALE_TIME = -1;

15
src/share/system_variable/ob_system_variable_init.cpp
View File

@ -5886,13 +5886,26 @@ static struct VarsInit{
ObSysVars[416].alias_ = "OB_SV_SUPER_READ_ONLY" ;
}();
[&] (){
ObSysVars[417].default_value_ = "2" ;
ObSysVars[417].info_ = "PLSQL_OPTIMIZE_LEVEL specifies the optimization level that will be used to compile PL/SQL library units. The higher the setting of this parameter, the more effort the compiler makes to optimize PL/SQL library units." ;
ObSysVars[417].name_ = "plsql_optimize_level" ;
ObSysVars[417].data_type_ = ObIntType ;
ObSysVars[417].flags_ = ObSysVarFlag::SESSION_SCOPE | ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::NEED_SERIALIZE ;
ObSysVars[417].id_ = SYS_VAR_PLSQL_OPTIMIZE_LEVEL ;
cur_max_var_id = MAX(cur_max_var_id, static_cast<int64_t>(SYS_VAR_PLSQL_OPTIMIZE_LEVEL)) ;
ObSysVarsIdToArrayIdx[SYS_VAR_PLSQL_OPTIMIZE_LEVEL] = 417 ;
ObSysVars[417].base_value_ = "2" ;
ObSysVars[417].alias_ = "OB_SV_PLSQL_OPTIMIZE_LEVEL" ;
}();
if (cur_max_var_id >= ObSysVarFactory::OB_MAX_SYS_VAR_ID) {
HasInvalidSysVar = true;
}
}
}vars_init;
static int64_t var_amount = 417;
static int64_t var_amount = 418;
int64_t ObSysVariables::get_all_sys_var_count(){ return ObSysVarFactory::ALL_SYS_VARS_COUNT;}
ObSysVarClassType ObSysVariables::get_sys_var_id(int64_t i){ return ObSysVars[i].id_;}

13
src/share/system_variable/ob_system_variable_init.json
View File

@ -6985,5 +6985,18 @@
"background_cn": "",
"ref_url": "",
"placeholder": true
},
"plsql_optimize_level": {
"id": 10393,
"name": "plsql_optimize_level",
"default_value": "2",
"base_value": "2",
"data_type": "int",
"info": "PLSQL_OPTIMIZE_LEVEL specifies the optimization level that will be used to compile PL/SQL library units. The higher the setting of this parameter, the more effort the compiler makes to optimize PL/SQL library units.",
"flags": "SESSION | GLOBAL | NEED_SERIALIZE",
"publish_version": "423",
"info_cn": "",
"background_cn": "",
"ref_url": ""
}
}

38
src/sql/session/ob_basic_session_info.cpp
View File

@ -6488,6 +6488,9 @@ void ObExecEnv::reset()
collation_connection_ = CS_TYPE_INVALID;
collation_database_ = CS_TYPE_INVALID;
plsql_ccflags_.reset();
// default PLSQL_OPTIMIZE_LEVEL = 2
plsql_optimize_level_ = 2;
}
bool ObExecEnv::operator==(const ObExecEnv &other) const
@ -6496,7 +6499,8 @@ bool ObExecEnv::operator==(const ObExecEnv &other) const
&& charset_client_ == other.charset_client_
&& collation_connection_ == other.collation_connection_
&& collation_database_ == other.collation_database_
&& plsql_ccflags_ == other.plsql_ccflags_;
&& plsql_ccflags_ == other.plsql_ccflags_
&& plsql_optimize_level_ == other.plsql_optimize_level_;
}
bool ObExecEnv::operator!=(const ObExecEnv &other) const
@ -6535,7 +6539,8 @@ int ObExecEnv::gen_exec_env(const ObBasicSessionInfo &session, char* buf, int64_
case SQL_MODE:
case CHARSET_CLIENT:
case COLLATION_CONNECTION:
case COLLATION_DATABASE: {
case COLLATION_DATABASE:
case PLSQL_OPTIMIZE_LEVEL: {
int64_t size = 0;
val.reset();
OZ (session.get_sys_variable(ExecEnvMap[i], val));
@ -6597,7 +6602,8 @@ int ObExecEnv::gen_exec_env(const share::schema::ObSysVariableSchema &sys_variab
case SQL_MODE:
case CHARSET_CLIENT:
case COLLATION_CONNECTION:
case COLLATION_DATABASE: {
case COLLATION_DATABASE:
case PLSQL_OPTIMIZE_LEVEL: {
int64_t size = 0;
if (OB_FAIL(sys_variable.get_sysvar_schema(ExecEnvMap[i], sysvar_schema))) {
LOG_WARN("failed to get sysvar schema", K(ret));
@ -6653,7 +6659,14 @@ int ObExecEnv::init(const ObString &exec_env)
int ret = OB_SUCCESS;
ObString value_str;
ObString start = exec_env;
bool is_oracle_mode = lib::is_oracle_mode();
for (int64_t i = 0; OB_SUCC(ret) && i < MAX_ENV; ++i) {
// mysql mode do not have plsql_ccflags_length
if (PLSQL_CCFLAGS == i && !is_oracle_mode) {
continue;
}
GET_ENV_VALUE(start, value_str);
if (OB_SUCC(ret)) {
switch (i) {
@ -6679,11 +6692,20 @@ int ObExecEnv::init(const ObString &exec_env)
} else {
int32_t plsql_ccflags_length = 0;
SET_ENV_VALUE(plsql_ccflags_length, int32_t);
CK (plsql_ccflags_length >= 0);
if (OB_FAIL(ret)) {
} else if (plsql_ccflags_length > 0) {
plsql_ccflags_.assign(start.ptr(), plsql_ccflags_length);
start += plsql_ccflags_length + 1;// 1 for ','
}
OX (start += plsql_ccflags_length + 1);// 1 for ','
}
}
break;
case PLSQL_OPTIMIZE_LEVEL: {
if (value_str.empty()) {
// do nothing, old routine object version do not have plsql_optimize_level
} else {
SET_ENV_VALUE(plsql_optimize_level_, int64_t);
}
}
break;
@ -6737,6 +6759,10 @@ int ObExecEnv::load(ObBasicSessionInfo &session, ObIAllocator *alloc)
}
}
break;
case PLSQL_OPTIMIZE_LEVEL: {
plsql_optimize_level_ = static_cast<int64_t>(val.get_int());
}
break;
default: {
ret = common::OB_ERR_UNEXPECTED;
LOG_WARN("Invalid env type", K(i), K(ret));
@ -6776,6 +6802,10 @@ int ObExecEnv::store(ObBasicSessionInfo &session)
val.set_collation_type(ObCharset::get_system_collation());
}
break;
case PLSQL_OPTIMIZE_LEVEL: {
val.set_int(plsql_optimize_level_);
}
break;
default: {
ret = common::OB_ERR_UNEXPECTED;
LOG_WARN("Invalid env type", K(i), K(ret));

13
src/sql/session/ob_basic_session_info.h
View File

@ -2592,6 +2592,7 @@ public:
COLLATION_CONNECTION,
COLLATION_DATABASE,
PLSQL_CCFLAGS,
PLSQL_OPTIMIZE_LEVEL,
MAX_ENV,
};
@ -2601,6 +2602,7 @@ public:
share::SYS_VAR_COLLATION_CONNECTION,
share::SYS_VAR_COLLATION_DATABASE,
share::SYS_VAR_PLSQL_CCFLAGS,
share::SYS_VAR_PLSQL_OPTIMIZE_LEVEL,
share::SYS_VAR_INVALID
};
@ -2609,7 +2611,9 @@ public:
charset_client_(CS_TYPE_INVALID),
collation_connection_(CS_TYPE_INVALID),
collation_database_(CS_TYPE_INVALID),
plsql_ccflags_() {}
plsql_ccflags_(),
plsql_optimize_level_(2) // default PLSQL_OPTIMIZE_LEVEL = 2
{ }
virtual ~ObExecEnv() {}
@ -2617,7 +2621,8 @@ public:
K_(charset_client),
K_(collation_connection),
K_(collation_database),
K_(plsql_ccflags));
K_(plsql_ccflags),
K_(plsql_optimize_level));
void reset();
@ -2642,12 +2647,16 @@ public:
void set_plsql_ccflags(ObString &plsql_ccflags) { plsql_ccflags_ = plsql_ccflags; }
int64_t get_plsql_optimize_level() { return plsql_optimize_level_; }
void set_plsql_optimize_level(int64_t level) { plsql_optimize_level_ = plsql_optimize_level_; }
private:
ObSQLMode sql_mode_;
ObCollationType charset_client_;
ObCollationType collation_connection_;
ObCollationType collation_database_;
ObString plsql_ccflags_;
int64_t plsql_optimize_level_;
};

2
tools/deploy/mysql_test/test_suite/inner_table/r/mysql/all_virtual_sys_parameter_stat.result
View File

@ -180,7 +180,6 @@ partition_balance_schedule_interval
plan_cache_evict_interval
plsql_code_type
plsql_debug
plsql_optimize_level
plsql_v2_compatibility
px_task_size
px_workers_per_cpu_quota
@ -385,6 +384,7 @@ _ob_max_thread_num
_ob_obj_dep_maint_task_interval
_ob_plan_cache_auto_flush_interval
_ob_plan_cache_gc_strategy
_ob_pl_compile_max_concurrency
_ob_query_rate_limit
_ob_ssl_invited_nodes
_ob_trans_rpc_timeout