hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
fa010efcd474b25ae00a7a82b31b35213c63b4d6
oceanbase/src/sql/plan_cache/ob_sql_parameterization.cpp

2346 lines
102 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_PC
#include "ob_sql_parameterization.h"
#include "share/schema/ob_schema_struct.h"
#include "lib/json/ob_json_print_utils.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/parser/ob_parser.h"
#include "sql/parser/ob_fast_parser.h"
#include "sql/resolver/ob_resolver_utils.h"
#include "sql/parser/parse_malloc.h"
#include "sql/ob_sql_utils.h"
#include "common/ob_smart_call.h"
#include <algorithm>
using namespace oceanbase;
using namespace sql;
using namespace common;
using namespace share::schema;
SqlInfo::SqlInfo() :
total_(0),
last_active_time_(0),
hit_count_(0),
ps_need_parameterized_(true),
need_check_fp_(false)
{
}
namespace oceanbase {
namespace sql {
struct TransformTreeCtx
{
ObIAllocator *allocator_;
ParseNode *top_node_;
ParseNode *tree_;
ObStmtScope expr_scope_;
int64_t value_father_level_;
ObCollationType collation_type_;
ObCollationType national_collation_type_;
const ObTimeZoneInfo *tz_info_;
int64_t question_num_;
ParamStore *params_;
ObMaxConcurrentParam::FixParamStore *fixed_param_store_;
bool not_param_; //表示该节点及其子节点是常量时也不能参数化
bool is_fast_parse_const_; //表示当前node是否为fp可识别的常量
bool enable_contain_param_;//表示该节点及其子节点中常量是否为fp可识别的参数。
SqlInfo *sql_info_;
int64_t paramlized_questionmask_count_;//表示该查询中可以被参数化的?个数，用于sql限流
bool is_transform_outline_;//是否在resolve outline, 用于sql限流
ObLengthSemantics default_length_semantics_;
ObSEArray<void*, 16> project_list_; // 记录下所有T_PROJECT_STRING节点
const ObIArray<ObPCParam *> *raw_params_;
SQL_EXECUTION_MODE mode_;
bool is_project_list_scope_;
int64_t assign_father_level_;
const ObIArray<FixedParamValue> *udr_fixed_params_;
bool ignore_scale_check_;
bool is_from_pl_;
TransformTreeCtx();
};
struct SelectItemTraverseCtx
{
const common::ObIArray<ObPCParam *> &raw_params_;
const ParseNode *tree_;
const ObString &org_expr_name_;
const int64_t expr_start_pos_;
const int64_t buf_len_;
int64_t &expr_pos_;
SelectItemParamInfo &param_info_;
SelectItemTraverseCtx(const common::ObIArray<ObPCParam *> &raw_params,
const ParseNode *tree,
const ObString &org_expr_name,
const int64_t expr_start_pos,
const int64_t buf_len,
int64_t &expr_pos,
SelectItemParamInfo &param_info)
: raw_params_(raw_params), tree_(tree), org_expr_name_(org_expr_name),
expr_start_pos_(expr_start_pos), buf_len_(buf_len), expr_pos_(expr_pos), param_info_(param_info) {}
};
struct TraverseStackFrame
{
const ParseNode *cur_node_;
int64_t next_child_idx_;
TO_STRING_KV(K_(next_child_idx),
K(cur_node_->type_));
};
}
}
TransformTreeCtx::TransformTreeCtx() :
allocator_(NULL),
top_node_(NULL),
tree_(NULL),
expr_scope_(T_NONE_SCOPE),
value_father_level_(ObSqlParameterization::NO_VALUES),
collation_type_(),
national_collation_type_(CS_TYPE_INVALID),
tz_info_(NULL),
question_num_(0),
params_(NULL),
fixed_param_store_(NULL),
not_param_(false),
is_fast_parse_const_(false),
enable_contain_param_(true),
sql_info_(NULL),
paramlized_questionmask_count_(0),
is_transform_outline_(false),
default_length_semantics_(LS_BYTE),
raw_params_(NULL),
mode_(INVALID_MODE),
is_project_list_scope_(false),
assign_father_level_(ObSqlParameterization::NO_VALUES),
udr_fixed_params_(NULL),
ignore_scale_check_(false),
is_from_pl_(false)
{
}
// replace const expr with ? in syntax tree
// seprate params from syntax tree
int ObSqlParameterization::transform_syntax_tree(ObIAllocator &allocator,
const ObSQLSessionInfo &session,
const ObIArray<ObPCParam *> *raw_params,
ParseNode *tree,
SqlInfo &sql_info,
ParamStore &params,
SelectItemParamInfoArray *select_item_param_infos,
ObMaxConcurrentParam::FixParamStore &fixed_param_store,
bool is_transform_outline,
SQL_EXECUTION_MODE execution_mode,
const ObIArray<FixedParamValue> *udr_fixed_params,
bool is_from_pl)
{
int ret = OB_SUCCESS;
ObCollationType collation_connection = CS_TYPE_INVALID;
ParseNode *children_node = tree->children_[0];
if (OB_ISNULL(tree)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(tree), K(ret));
} else if (OB_ISNULL(children_node)){
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(tree), K(ret));
} else if (OB_FAIL(session.get_collation_connection(collation_connection))) {
SQL_PC_LOG(WARN, "fail to get collation_connection", K(ret));
} else {
sql_info.sql_traits_.stmt_type_ = children_node->type_;
TransformTreeCtx ctx;
ctx.collation_type_ = collation_connection;
ctx.national_collation_type_ = session.get_nls_collation_nation();
ctx.tz_info_ = session.get_timezone_info();
ctx.default_length_semantics_ = session.get_actual_nls_length_semantics();
ctx.allocator_ = &allocator;
ctx.tree_ = tree;
ctx.top_node_ = tree;
ctx.expr_scope_ = T_NONE_SCOPE;
ctx.value_father_level_ = NO_VALUES;
ctx.question_num_ = 0;
ctx.params_ = &params;
ctx.fixed_param_store_ = &fixed_param_store;
ctx.not_param_ = false;
ctx.is_fast_parse_const_ = false;
ctx.enable_contain_param_ = true;
ctx.sql_info_ = &sql_info;
ctx.paramlized_questionmask_count_ = 0;//used for outline sql限流，
ctx.is_transform_outline_ = is_transform_outline;//used for outline sql限流
ctx.raw_params_ = raw_params;
ctx.udr_fixed_params_ = udr_fixed_params;
ctx.is_project_list_scope_ = false;
ctx.mode_ = execution_mode;
ctx.assign_father_level_ = NO_VALUES;
ctx.is_from_pl_ = is_from_pl;
if (OB_FAIL(transform_tree(ctx, session))) {
if (OB_NOT_SUPPORTED != ret) {
SQL_PC_LOG(WARN, "fail to transform syntax tree", K(ret));
}
} else if (is_transform_outline && (INT64_MAX != children_node->value_)
&& (children_node->value_ != ctx.paramlized_questionmask_count_)) {
ret = OB_INVALID_OUTLINE;
LOG_USER_ERROR(OB_INVALID_OUTLINE, "? appears at invalid position in sql_text");
SQL_PC_LOG(WARN, "? appear at invalid position", "total count of questionmasks in query", children_node->value_,
"paramlized_questionmask_count", ctx.paramlized_questionmask_count_, K(ret));
} else if (OB_NOT_NULL(raw_params)
&& OB_NOT_NULL(select_item_param_infos)) {
if (sql_info.total_ != raw_params->count()) {
ret = OB_NOT_SUPPORTED;
SQL_PC_LOG(TRACE, "const number of fast parse and normal parse is different",
"fast_parse_const_num", raw_params->count(),
"normal_parse_const_num", sql_info.total_,
K(session.get_current_query_string()),
"result_tree_", SJ(ObParserResultPrintWrapper(*ctx.top_node_)));
} else {
select_item_param_infos->set_capacity(ctx.project_list_.count());
for (int64_t i = 0; OB_SUCC(ret) && i < ctx.project_list_.count(); i++) {
ParseNode *tmp_root = static_cast<ParseNode *>(ctx.project_list_.at(i));
if (OB_ISNULL(tmp_root)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid null child", K(ret), K(i), K(ctx.project_list_.at(i)));
} else if (0 == tmp_root->is_val_paramed_item_idx_
&& OB_FAIL(get_select_item_param_info(*raw_params,
tmp_root,
select_item_param_infos))) {
SQL_PC_LOG(WARN, "failed to get select item param info", K(ret));
} else {
// do nothing
}
} // for end
}
}
SQL_PC_LOG(DEBUG, "after transform_tree",
"result_tree_", SJ(ObParserResultPrintWrapper(*tree)));
}
return ret;
}
//判断是否是fast parse能识别的常量(只考虑本node)
//
//T_CAST_ARGUMENT,T_FUN_SYS_CUR_TIMESTAMP, T_SFU_INT
//该类型node在快速参数化时是常数(eg:cast ( 10 AS CHAR(20)中20, now(10))；
//但正常parse时node结点类型为不在常数范围,
//该node不需要参数化，但为了保证正常parse和fast parse常量个数匹配，所以加入特殊判断;
//该参数在正常parse时处理方式和order by中参数相同;
//
//T_SFU_INT 和T_FUN_SYS_UTC_TIME时判段为0 或-1，
//是因为now()和FOR UPDATE没有参数，但语法会给默认值,加判断是为了让正常parse不认为该值为常量。
int ObSqlParameterization::is_fast_parse_const(TransformTreeCtx &ctx)
{
int ret = OB_SUCCESS;
if (NULL == ctx.tree_) { //parse tree中存在node为NULL
ctx.is_fast_parse_const_ = false;
} else {
//如果其节点为T_HINT_OPTION_LIST则该节点及其子节点中常量都不是fp可识别的参数参数。
if (T_HINT_OPTION_LIST == ctx.tree_->type_) {
ctx.enable_contain_param_ = false;
}
if (ctx.enable_contain_param_) {
//当该node为T_NULL/T_VARCHAR类型且is_hidden_const_为true时表示该node在fast parse中不能识别为常量
if ((T_NULL == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_VARCHAR == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_INT == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_CAST_ARGUMENT == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_DOUBLE == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_IEEE754_INFINITE == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_IEEE754_NAN == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_SFU_INT == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| (T_FLOAT == ctx.tree_->type_ && true == ctx.tree_->is_hidden_const_)
|| true == ctx.tree_->is_forbid_parameter_) {
ctx.is_fast_parse_const_ = false;
} else {
ctx.is_fast_parse_const_ = (IS_DATATYPE_OP(ctx.tree_->type_)
|| T_QUESTIONMARK == ctx.tree_->type_
|| T_COLLATION == ctx.tree_->type_
|| T_CAST_ARGUMENT == ctx.tree_->type_
|| T_NULLX_CLAUSE == ctx.tree_->type_
|| (T_SFU_INT == ctx.tree_->type_ && -1 != ctx.tree_->value_)
|| T_SFU_DECIMAL == ctx.tree_->type_
|| T_WEIGHT_STRING_LEVEL_PARAM == ctx.tree_->type_);
}
} else {
ctx.is_fast_parse_const_ = false;
}
}
return ret;
}
bool ObSqlParameterization::is_udr_not_param(TransformTreeCtx &ctx)
{
bool b_ret = false;
if (OB_ISNULL(ctx.tree_) || (NULL == ctx.udr_fixed_params_)) {
b_ret = false;
} else {
for (int64_t i = 0; !b_ret && i < ctx.udr_fixed_params_->count(); ++i) {
const FixedParamValue &fixed_param = ctx.udr_fixed_params_->at(i);
if (fixed_param.idx_ == ctx.tree_->raw_param_idx_) {
b_ret = true;
break;
}
}
}
return b_ret;
}
//判断该node是否为不能参数化的node
bool ObSqlParameterization::is_node_not_param(TransformTreeCtx &ctx)
{
bool not_param = false;
if (NULL == ctx.tree_) {
not_param = true;
} else if (!ctx.is_fast_parse_const_) {
not_param = true;
} else if (ctx.not_param_) { //如果其本身或其祖先已经判定了所有子节点为not param, 则为not param
not_param = true;
} else {
not_param = false;
}
return not_param;
}
//判断该节点及其子节点是常量时也不能参数化。
bool ObSqlParameterization::is_tree_not_param(const ParseNode *tree)
{
bool ret_bool = false;
if (NULL == tree) {
ret_bool = true;
} else if (true == tree->is_tree_not_param_) {
ret_bool = true;
} else if (lib::is_mysql_mode() && T_GROUPBY_CLAUSE == tree->type_) {
// oracle模式下，select a from t group by 1这种语法被禁止，所以可以开放group by的参数化
ret_bool = true;
} else if (T_SORT_LIST == tree->type_) {
ret_bool = true;
} else if (T_HINT_OPTION_LIST == tree->type_) {
ret_bool = true;
} else if (T_COLLATION == tree->type_) {
ret_bool = true;
} else if (T_CAST_ARGUMENT == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_UTC_TIMESTAMP == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_UTC_TIME == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_SYSDATE == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_SYSTIMESTAMP == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_CUR_TIMESTAMP == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_LOCALTIMESTAMP == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_CUR_TIME == tree->type_) {
ret_bool = true;
} else if (T_FUN_SYS_CUR_DATE == tree->type_) {
ret_bool = true;
} else if (T_SFU_INT == tree->type_ ||
T_SFU_DECIMAL == tree->type_ ||
T_SFU_DOUBLE == tree->type_) {
ret_bool = true;
} else if (T_CYCLE_NODE == tree->type_) {
ret_bool = true;
} else if (T_INTO_FIELD_LIST == tree->type_) {
ret_bool = true;
} else if (T_INTO_LINE_LIST == tree->type_) {
ret_bool = true;
} else if (T_PIVOT_IN_LIST == tree->type_) {
ret_bool = true;
} else if (T_CHAR_CHARSET == tree->type_) {
ret_bool = true;
} else if (T_WIN_NAMED_WINDOWS == tree->type_) {//name window无法参数化，因为无法保证其参数化顺序
ret_bool = true;
} else {
// do nothing
}
return ret_bool;
}
SQL_EXECUTION_MODE ObSqlParameterization::get_sql_execution_mode(ObPlanCacheCtx &pc_ctx)
{
SQL_EXECUTION_MODE mode = INVALID_MODE;
if (PC_PS_MODE == pc_ctx.mode_ || PC_PL_MODE == pc_ctx.mode_) {
if (pc_ctx.is_parameterized_execute_) {
mode = (PC_PL_MODE == pc_ctx.mode_) ? PL_EXECUTE_MODE : PS_EXECUTE_MODE;
} else {
mode = (PC_PL_MODE == pc_ctx.mode_) ? PL_PREPARE_MODE : PS_PREPARE_MODE;
}
} else {
mode = TEXT_MODE;
}
return mode;
}
bool ObSqlParameterization::is_prepare_mode(SQL_EXECUTION_MODE mode)
{
return (PS_PREPARE_MODE == mode || PL_PREPARE_MODE == mode);
}
bool ObSqlParameterization::is_execute_mode(SQL_EXECUTION_MODE mode)
{
return (PS_EXECUTE_MODE == mode || PL_EXECUTE_MODE == mode);
}
/* fix:
* decide if a number param can ignore scale check when choosing plancache.
* if current node type is expr list or number,
* and parent node is point, st_point, json array, or ctx.ignore_scale_check_ is true, return true,
* otherwise return false.
* example1 scale check could ignore:
* 'select point(1.1, 1.1)' and 'select point(1.1111, 1.1111)' could share a same plancache,
* scale check about number literal in them are ignored
* example2 scale check cannot ignore:
* 'select point(cast(1.11 as double), 1.1)' and 'select point(cast(1.1111 as double), 1.1111)'
* because 1.11 and 1.1111 in cast expr have different scales,
* scale check will prevent them to share a same plancache
*/
bool ObSqlParameterization::is_ignore_scale_check(TransformTreeCtx &ctx, const ParseNode *parent)
{
bool ret_bool = false;
if (OB_ISNULL(parent) || OB_ISNULL(ctx.tree_)) {
// do nothing
} else if (T_EXPR_LIST == ctx.tree_->type_ || T_NUMBER == ctx.tree_->type_) {
if (T_NUMBER == ctx.tree_->type_ && ctx.ignore_scale_check_) {
ret_bool = true;
} else if (T_FUN_SYS_POINT == parent->type_) {
ret_bool = true;
} else if (T_FUN_SYS == parent->type_) {
ParseNode **node = parent->children_;
if (OB_ISNULL(node) || OB_ISNULL(node[0])) {
// do nothing
} else {
ObString func_name(node[0]->str_len_, node[0]->str_value_);
if ((0 == func_name.case_compare("st_point"))) {
ret_bool = true;
}
}
} else { /* do nothing*/ }
} else { /* do nothing*/ }
return ret_bool;
}
// helper method of transform_syntax_tree
//正常parse和fast parse识别常量不一致的问题
/*
* 1.replace/insert的列带括号为空时导致正常parse和fast parse识别常量不一致
* eg:replace into t2() values(40, 1, 'good')
* 原因：主要是因为opt_insert_columns，含括号，但为空时，会默认生成T_NULL节点，导致正常parse和fast parse识别常量不一致。
* 解法：将T_NULL类型改成T_EMPTY类型即可，在resolver阶段并没有对该类型识别，而是使用这种判断进行处理if （T_COLUMN_LIST ==）else {//处理为空的情况}
*2.default()导致的正常parse和fast parse常量不一致
* eg :select * from type_t where int_c = default(int_c)
* 原因：default()在语法阶段生成4个T_NULL类型的null_node，在resolve阶段会填充具体的内容，导致不一致。
* 解法：将生成的null_node中is_hidden_const_字段置1， 在transform tree阶段，判断node为T_NULL类型且is_hidden_const_为true时表示该node在fast parse中不能识别为常量，从而不参数化，保证正常parse和fast parse识别常量一致。
*3.using charset_name导致的正常parse和fast parse识别常量不一致
* eg:select convert('1234' using 'utf8’);
* eg:select convert('1234' using utf8);
* 原因：using ‘utf8’ 和using utf8均会生成都会生成一个T_VARCHAR类型的节点，对于using utf8, fast parse不能识别出常量，因此导致正常parse和fast parse识别不一致。
* 解法：将using utf8生成的T_VARCHAR节点中is_hidden_const_字段置1，在transform tree阶段，判断node为T_VARCHAR类型且is_hidden_const_为true时表示该node在fast parse中不能识别为常量，从而不参数化，保证正常parse和fast parse识别常量一致。
*4.month等date_unit导致的正常parse和fast parse识别常量个数不一致
* eg:SELECT month(NULL);
* select * from type_t where date_c = date_add('2015-01-01', interval 5 month)
* 问题：在语法阶段，mouth，day等date_unit是解析为T_INT类型的节点，导致正常parse与fast parse识别不一致。之前的方案是将mouth等date_unit在词法阶段识别出来，并生成对应的 T_INT类型节点解决该问题。但这导致mouth()作为函数或当sql中存在以month等date_unit命名的table或unit时会导致正常parse与fast parse识别常量不一致的问题。
* 解法：将month,day等date_unit生成的T_INT节点中is_hidden_const_字段置1，在transform tree阶段，判断node为T_INT类型且is_hidden_const_为true时表示该node在fast parse中不能识别为常量，从而不参数化，保证正常parse和fast parse识别常量一致。
*5.as STRING_VALUE导致的正常parse和fast parse识别常量不一致
* eg: select 'abc' as a;
* select 'abc' as ‘a’;
* 问题：as a 和 as ‘a’ 在语法阶段会生成T_ALIAS节点，导致对于as ‘a’在fast parse能识别一个常量，而正常parse不能识别出常量。
* 解法：在T_ALIAS节点中记录对应的fast parse能够识别的常量个数（0个或1个），在transform时，如果是T_ALIAS节点，则将其判断为不能参数化的常量，并将对应的常量个数记下，从而保证下次fast parse时能够识别的常量的个数一致。
*
*6. 问题: 当函数中存在格式字符串时, 格式字符串不需要参数化, eg:STR_TO_DATE, FROM_UNIXTIME, DATE_FORMAT
* 解法: 在参数化过程中，遍历parse tree，识别到T_FUN_SYS节点后，识别第一个children（函数名）,然后遍历所有child，并对含格式串的函数中格式化参数节点及其子节点(该格式串可能由函数生成)均做不需要参数化标记。
*
* 7. 问题: weight_string函数在包含level参数时，level可以是变长的、结构化的数据，此时normal_parser会将level的常数进行扁平化处理（只有一个T_INT类型的ParseNode），但是fast_parser会识别到所有的数字，导致两者常量数量不一致
* eg:
* select weight_string("AAA" as char(1) level 1-2 );
* select weight_string("AAA" as char(1) level 1,2,3,4,5,6,7,8,9,10,11 );
* select weight_string("AAA" as char(1) level 1 desc,2 asc ,3 desc ,4 reverse,5,6,7,8,9 reverse,10,11 );
* 解法：创建一个新的item_type(T_WEIGHT_STRING_LEVEL_PARAM) ，根据不同的语法来设置不同的param_num_,这样normal_parser就可以和faster_parser相等了，等到具体处理T_WEIGHT_STRING_LEVEL_PARAM的时候,把它转换为T_INT进行后续的处理。
*/
int ObSqlParameterization::transform_tree(TransformTreeCtx &ctx,
const ObSQLSessionInfo &session_info)
{
int ret = OB_SUCCESS;
int64_t value_level = NO_VALUES;
int64_t assign_level = NO_VALUES;
if (OB_ISNULL(ctx.top_node_)
|| OB_ISNULL(ctx.allocator_)
|| OB_ISNULL(ctx.sql_info_)
|| OB_ISNULL(ctx.fixed_param_store_)
|| OB_ISNULL(ctx.params_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "top node is NULL",
K(ctx.top_node_),
K(ctx.allocator_),
K(ctx.sql_info_),
K(ctx.fixed_param_store_),
K(ctx.params_),
K(ret));
} else if (NULL == ctx.tree_) {
// do nothing
} else {
ParseNode *func_name_node = NULL;
if (T_WHERE_SCOPE == ctx.expr_scope_ && T_FUN_SYS == ctx.tree_->type_) {
if (OB_ISNULL(ctx.tree_->children_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ctx.tree_->children_), K(ret));
} else if (NULL == (func_name_node = ctx.tree_->children_[0])) {
ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(ERROR, "function name node is NULL", K(ret));
} else {
ObString func_name(func_name_node->str_len_, func_name_node->str_value_);
ObString func_name_is_serving_tenant(N_IS_SERVING_TENANT);
if (func_name == func_name_is_serving_tenant) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("is_serving_tenant is not supported", K(ret));
}
}
}
if (OB_SUCC(ret) && T_PROJECT_STRING == ctx.tree_->type_
&& OB_FAIL(ctx.project_list_.push_back(ctx.tree_))) {
LOG_WARN("failed to push back element", K(ret));
} else {
// do nothing
}
if (OB_SUCC(ret)) {
ObObjParam value;
ObAccuracy tmp_accuracy;
bool is_fixed = true;
if (ctx.is_fast_parse_const_) { //这里面需要获取fast parse识别为常量的所有信息
if (!is_node_not_param(ctx)) { //判定是否为可以参数化的常量
//for sql 限流
ParseNode* node = NULL;
if (OB_NOT_NULL(ctx.raw_params_) &&
ctx.tree_->value_ < ctx.raw_params_->count() &&
T_QUESTIONMARK == ctx.tree_->type_ &&
!is_prepare_mode(ctx.mode_)) {
node = ctx.raw_params_->at(ctx.tree_->value_)->node_;
} else {
node = ctx.tree_;
}
if (T_QUESTIONMARK == ctx.tree_->type_) {
ctx.paramlized_questionmask_count_++;
is_fixed = false;
}
ObString literal_prefix;
int64_t server_collation = CS_TYPE_INVALID;
if (lib::is_oracle_mode() &&OB_FAIL(
session_info.get_sys_variable(share::SYS_VAR_COLLATION_SERVER, server_collation))) {
LOG_WARN("get sys variable failed", K(ret));
} else if (OB_FAIL(add_param_flag(ctx.tree_, *ctx.sql_info_))) {
SQL_PC_LOG(WARN, "fail to get neg flag", K(ret));
} else if (OB_FAIL(ObResolverUtils::resolve_const(node,
static_cast<stmt::StmtType>(ctx.sql_info_->sql_traits_.stmt_type_),
*(ctx.allocator_),
ctx.collation_type_,
ctx.national_collation_type_,
ctx.tz_info_,
value,
ctx.is_transform_outline_,
literal_prefix,
ctx.default_length_semantics_,
static_cast<ObCollationType>(server_collation),
NULL, session_info.get_sql_mode(), ctx.is_from_pl_))) {
SQL_PC_LOG(WARN, "fail to resolve const", K(ret));
} else {
//对于字符串值，其T_VARCHAR型的parse node有一个T_VARCHAR类型的子node，该子node描述字符串的charset等信息。
//因此对于可参数化的参数，当该节点的父节点为T_VALUE_VECTOR, 且类型为T_VARCHAR或没有子node时，认为是单值(不属于复杂表达式中参数);
//此时将value中单值参数标记为不需要在plan cache中强匹配类型的参数
if ((VALUE_VECTOR_LEVEL == ctx.value_father_level_
|| ASSIGN_ITEM_LEVEL == ctx.assign_father_level_)
&& (0 == ctx.tree_->num_child_
|| T_VARCHAR == ctx.tree_->type_
|| (lib::is_oracle_mode() && T_CHAR == ctx.tree_->type_)
|| T_QUESTIONMARK == ctx.tree_->type_)) {
if (T_QUESTIONMARK == ctx.tree_->type_) {
if (OB_FAIL(ctx.sql_info_->no_check_type_offsets_.push_back(ctx.tree_->value_))) {
SQL_PC_LOG(WARN, "failed to add no check type offsets", K(ret));
}
} else {
value.set_need_to_check_type(false);
}
} else {
if (T_QUESTIONMARK == ctx.tree_->type_) {
if (OB_FAIL(ctx.sql_info_->need_check_type_param_offsets_.add_member(ctx.tree_->value_))) {
SQL_PC_LOG(WARN, "failed to add member", K(ctx.tree_->value_));
}
} else {
value.set_need_to_check_type(true);
}
if (ctx.ignore_scale_check_) {
value.set_ignore_scale_check(true);
}
}
//用于sql限流，记录哪些参数需要严格比对
if (OB_SUCC(ret) && is_fixed) {
ObFixedParam fix_param;
fix_param.offset_ = ctx.params_->count();
fix_param.value_ = value;
if (OB_FAIL(ctx.fixed_param_store_->push_back(fix_param))) {
SQL_PC_LOG(WARN, "fail to push back fix params", K(fix_param), K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(add_varchar_charset(ctx.tree_, *ctx.sql_info_))) {
SQL_PC_LOG(WARN, "fail to add varchar charset", K(ret));
}
}
if (OB_SUCC(ret) && ctx.tree_->type_ != T_QUESTIONMARK) {
if (OB_FAIL(ctx.sql_info_->fixed_param_idx_.push_back(ctx.question_num_))) {
SQL_PC_LOG(WARN, "failed to add question mark idx", K(ret));
}
}
ctx.tree_->is_literal_bool_ = (T_BOOL == ctx.tree_->type_);
value.set_is_boolean(value.is_boolean() || ctx.tree_->is_literal_bool_);
if (T_QUESTIONMARK != ctx.tree_->type_ && ctx.is_project_list_scope_) {
ctx.sql_info_->ps_need_parameterized_ = false;
}
// If it is internal sql, such as pl internal sql, the formatted text string is used.
// because it is necessary to replace the sql variable in pl with the standard ps text
// for hard parsing. In this case, the param store has been constructed in advance
// so the constant cannot be resolved as a question mark, and there is no need to
// add it to the param store.
ObItemType node_type;
if (!is_execute_mode(ctx.mode_)) {
node_type = ctx.tree_->type_;
ctx.tree_->type_ = T_QUESTIONMARK;
ctx.tree_->raw_param_idx_ = ctx.sql_info_->total_;
ctx.tree_->value_ = ctx.question_num_;
}
ctx.question_num_++;
ctx.sql_info_->total_++;
if (1 == ctx.tree_->is_num_must_be_pos_ && OB_SUCC(ret)
&& OB_FAIL(ctx.sql_info_->must_be_positive_index_.add_member(ctx.tree_->raw_param_idx_))) {
LOG_WARN("failed to add bitset member", K(ret));
}
if (OB_NOT_NULL(ctx.tree_) &&
OB_NOT_NULL(ctx.raw_params_) &&
ctx.tree_->raw_param_idx_ >= 0 &&
ctx.tree_->raw_param_idx_ < ctx.raw_params_->count() &&
OB_NOT_NULL(ctx.raw_params_->at(ctx.tree_->raw_param_idx_))) {
const ParseNode *node = ctx.raw_params_->at(ctx.tree_->raw_param_idx_)->node_;
value.set_raw_text_info(static_cast<int32_t>(node->raw_sql_offset_),
static_cast<int32_t>(node->text_len_));
if (ctx.sql_info_->need_check_fp_) {
ObPCParseInfo p_info;
p_info.param_idx_ = ctx.sql_info_->total_ - 1;
p_info.flag_ = NORMAL_PARAM;
p_info.raw_text_pos_ = ctx.tree_->sql_str_off_;
if (ctx.tree_->sql_str_off_ == -1) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("invlid str off", K(lbt()), K(ctx.tree_),
K(ctx.tree_->raw_param_idx_), K(get_type_name(node_type)),
K(session_info.get_current_query_string()),
"result_tree_", SJ(ObParserResultPrintWrapper(*ctx.top_node_)));
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(ctx.sql_info_->parse_infos_.push_back(p_info))) {
SQL_PC_LOG(WARN, "fail to push parser info", K(ret));
}
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (!is_execute_mode(ctx.mode_) && OB_FAIL(ctx.params_->push_back(value))) {
SQL_PC_LOG(WARN, "fail to push into params", K(ret));
} else if (is_udr_not_param(ctx) && OB_FAIL(add_not_param_flag(ctx.tree_, *ctx.sql_info_))) {
SQL_PC_LOG(WARN, "fail to add not param flag", K(ret));
}
}
} else if (OB_FAIL(add_not_param_flag(ctx.tree_, *ctx.sql_info_))) { //not param
SQL_PC_LOG(WARN, "fail to add not param flag", K(ret));
}
if (ctx.sql_info_->need_check_fp_ && ret == OB_NOT_SUPPORTED) {
LOG_WARN("print tree", K(session_info.get_current_query_string()),
"result_tree_", SJ(ObParserResultPrintWrapper(*ctx.top_node_)));
}
} //if is_fast_parse_const end
}
// sql with charset need not ps parameterize
if (OB_SUCC(ret) && T_QUESTIONMARK == ctx.tree_->type_ && OB_NOT_NULL(ctx.tree_->children_)
&& OB_NOT_NULL(ctx.tree_->children_[0]) && ctx.tree_->children_[0]->type_ == T_CHARSET) {
ctx.sql_info_->ps_need_parameterized_ = false;
}
//判断insert中values()在tree中的哪一层，当某结点value_father_level_处于VALUE_VECTOR_LEVEL时,
//便可通过判断该节点的num_child_数是否为0,来判断values中的项是否为复杂表达式；
if (OB_SUCC(ret)) {
if (T_VALUE_LIST == ctx.tree_->type_) {
value_level = VALUE_LIST_LEVEL;
} else if (T_VALUE_VECTOR == ctx.tree_->type_
&& VALUE_LIST_LEVEL == ctx.value_father_level_) {
value_level = VALUE_VECTOR_LEVEL;
} else if (ctx.value_father_level_ >= VALUE_VECTOR_LEVEL) {
value_level = ctx.value_father_level_ + 1;
}
}
if (OB_SUCC(ret)) {
if (T_ASSIGN_LIST == ctx.tree_->type_) {
assign_level = ASSIGN_LIST_LEVEL;
} else if (T_ASSIGN_ITEM == ctx.tree_->type_
&& ASSIGN_LIST_LEVEL == ctx.assign_father_level_) {
assign_level = ASSIGN_ITEM_LEVEL;
} else if (ctx.assign_father_level_ >= ASSIGN_ITEM_LEVEL) {
assign_level = ctx.assign_father_level_ + 1;
}
}
// transform `operand - const_num_val` to `operand + (-const_num_val)`
if (OB_SUCC(ret) && OB_FAIL(transform_minus_op(*(ctx.allocator_), ctx.tree_, ctx.is_from_pl_))) {
LOG_WARN("failed to transform minums operation", K(ret));
} else if (lib::is_oracle_mode()) {
// in oracle mode, select +-1 from dual is prohibited, but with following orders, it can be executed successfully:
// 1. select +1 from dual; (genereted plan with key: select +? from dual)
// 2. select +-1 from dual; (hit plan before, executed successfully)
// Thus, add a constraint in plan cache: the numeric value following `-` or `+` operators must be posbitive number
if (T_OP_POS == ctx.tree_->type_ || T_OP_NEG == ctx.tree_->type_ ) {
if (OB_ISNULL(ctx.tree_->children_)
|| ctx.tree_->num_child_ != 1
|| OB_ISNULL(ctx.tree_->children_[0])) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid syntax tree", K(ret));
} else if (ob_is_numeric_type(ITEM_TO_OBJ_TYPE(ctx.tree_->children_[0]->type_))) {
ctx.tree_->children_[0]->is_num_must_be_pos_ = 1;
} else {
// do nothing
}
} else {
// do nothing
}
}
if (T_LIMIT_CLAUSE == ctx.tree_->type_) {
// limit a offset b, a and b must be postive
// 0 is counted as positive, -0 is counted as negative
if (OB_ISNULL(ctx.tree_->children_) || 2 != ctx.tree_->num_child_) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid syntax tree", K(ret),
K(ctx.tree_->children_), K(ctx.tree_->num_child_));
} else if (OB_NOT_NULL(ctx.tree_->children_[0])
&& ob_is_numeric_type(ITEM_TO_OBJ_TYPE(ctx.tree_->children_[0]->type_))
&& FALSE_IT(ctx.tree_->children_[0]->is_num_must_be_pos_ = 1)) {
} else if (OB_NOT_NULL(ctx.tree_->children_[1])
&& ob_is_numeric_type(ITEM_TO_OBJ_TYPE(ctx.tree_->children_[1]->type_))
&& FALSE_IT(ctx.tree_->children_[1]->is_num_must_be_pos_ = 1)) {
}
} else if (T_COMMA_LIMIT_CLAUSE == ctx.tree_->type_) {
// limit a, b, a and b must be postive
if (OB_ISNULL(ctx.tree_->children_)
|| 2 != ctx.tree_->num_child_
|| OB_ISNULL(ctx.tree_->children_[0])
|| OB_ISNULL(ctx.tree_->children_[1])) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid syntax tree", K(ret));
} else if (ob_is_numeric_type(ITEM_TO_OBJ_TYPE(ctx.tree_->children_[0]->type_))
&& FALSE_IT(ctx.tree_->children_[0]->is_num_must_be_pos_ = 1)) {
} else if (ob_is_numeric_type(ITEM_TO_OBJ_TYPE(ctx.tree_->children_[1]->type_))
&& FALSE_IT(ctx.tree_->children_[1]->is_num_must_be_pos_ = 1)) {
}
}
bool enable_contain_param = ctx.enable_contain_param_;
ParseNode *root = ctx.tree_;
//当type为T_QUESTIONMARK时不需要再考虑子节点的参数化,
//对于select '1'的T_VARCHAR和T_CHAR(oracle模式下) node有数据一样的T_VARCHAR子节点，
//由于select中投影列不需要参数化，所以会导致正常parse识别有两个常量，
//而fast parse只识别一个常量,所以在此加T_VARCHAR的判断, 使得两种parse均只能识别一个常量。
bool not_param = ctx.not_param_;
if (not_param) {
ctx.sql_info_->ps_need_parameterized_ = false;
}
bool is_project_list_scope = T_PROJECT_LIST == root->type_;
if (is_project_list_scope) {
ctx.is_project_list_scope_ = true;
}
bool ignore_scale_check = ctx.ignore_scale_check_;
for (int32_t i = 0;
OB_SUCC(ret) && i < root->num_child_ && root->type_ != T_QUESTIONMARK
&& root->type_ != T_VARCHAR && root->type_ != T_CHAR && root->type_ != T_NCHAR;
++i) {
//如果not_param本来就是true则不需要再判断；因为某结点判断为true，则该结点子树均为true；
if (OB_ISNULL(root->children_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ctx.tree_->children_), K(ret));
} else {
if (!ctx.not_param_) { //如果该节点及其子节点的常量均不为参数, 则不需要进行替换
//对T_OP_NEG节点进行改写,解决正负数不匹配问题
//如果是T_OP_NEG->T_INT节点，则改成T_INT节点且值乘-1;
//如果是T_OP_NEG->T_DOUBLE或T_NUMBER, 则改成T_DOUBLE或T_NUMBER节点的str前加－
if (OB_ISNULL(root->children_[i])
|| root->children_[i]->is_tree_not_param_) { //如果该children在mark tree时已标记为not_param, 则不需要处理neg
//do nothing
} else if (T_OP_NEG == root->children_[i]->type_ && 1 == root->children_[i]->num_child_) {
if (OB_ISNULL(root->children_[i]->children_) || OB_ISNULL(root->children_[i]->children_[0])) {
//do nothing
} else if (T_INT != root->children_[i]->children_[0]->type_
&& T_NUMBER != root->children_[i]->children_[0]->type_
&& T_DOUBLE != root->children_[i]->children_[0]->type_
&& T_FLOAT != root->children_[i]->children_[0]->type_
&& T_VARCHAR != root->children_[i]->children_[0]->type_) {
//do nothing
} else if (T_VARCHAR == root->children_[i]->children_[0]->type_) { //T_VARCHAR不需要insert neg
root->children_[i]->children_[0]->is_neg_ = 1;
} else if ((INT64_MIN == root->children_[i]->children_[0]->value_
&& T_INT == root->children_[i]->children_[0]->type_)
|| root->children_[i]->children_[0]->is_assigned_from_child_) {
// select --9223372036854775808 from dual;
// 9223372036854775809 之前的T_OP_NEG在语法阶段就被移除，这里在转换语法树的时候不需要再插入负号
// do nothing
} else if (OB_FAIL(insert_neg_sign(*(ctx.allocator_), root->children_[i]->children_[0]))) {
SQL_PC_LOG(WARN, "fail to insert neg sign", K(ret));
} else {
root->children_[i] = root->children_[i]->children_[0];
root->children_[i]->is_neg_ = 1;
}
}
}
if (OB_SUCC(ret)) {
if (T_STMT_LIST == root->type_) {
ctx.top_node_ = root->children_[i];
}
if (T_WHERE_CLAUSE == root->type_) { //目前只处理where clause
ctx.expr_scope_ = T_WHERE_SCOPE;
}
ctx.tree_ = root->children_[i];
ctx.value_father_level_ = value_level;
ctx.assign_father_level_ = assign_level;
if (T_PROJECT_STRING == root->type_) {
if (OB_ISNULL(ctx.tree_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid child for T_PROJECT_STRING", K(ret), K(ctx.tree_));
} else if (T_VARCHAR == ctx.tree_->type_
|| (lib::is_oracle_mode() && T_CHAR == ctx.tree_->type_)) {
// 标记这一个投影列是一个常量字符串，以便后续转义字符串
ctx.tree_->is_column_varchar_ = 1;
} else {
// do nothing
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(mark_tree(ctx.tree_ , *ctx.sql_info_))) {
SQL_PC_LOG(WARN, "fail to mark function tree", K(ctx.tree_), K(ret));
}
}
if (OB_SUCC(ret)) {
//如果not_param本来就是true则不需要再判断；因为某结点判断为true，则该结点子树均为true;
if (!ctx.not_param_) {
ctx.not_param_ = is_tree_not_param(ctx.tree_);
}
}
if (OB_SUCC(ret)) {
//判断该节点是否为fast_parse 认为的常量节点
ctx.enable_contain_param_ = enable_contain_param;
if (OB_FAIL(is_fast_parse_const(ctx))) {
SQL_PC_LOG(WARN, "judge is fast parse const failed", K(ret));
}
}
if (OB_SUCC(ret)) {
ctx.ignore_scale_check_ = is_ignore_scale_check(ctx, root);
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(SMART_CALL(transform_tree(ctx, session_info)))) {
if (OB_NOT_SUPPORTED != ret) {
SQL_PC_LOG(WARN, "fail to transform tree", K(ret));
}
} else {
ctx.not_param_ = not_param;
ctx.ignore_scale_check_ = ignore_scale_check;
if (T_ALIAS == root->type_ && 0 == i) {
// alias node的param_num_处理必须等到其第一个子节点转换完之后
// select a + 1 as 'a'，'a'不能被参数化，但是它在raw_params数组内的下标必须是计算了1的下标之后才能得到
// alias node只有一个或者0个参数
for (int64_t param_cnt = 0; OB_SUCC(ret) && param_cnt < root->param_num_; param_cnt++) {
if (OB_FAIL(ctx.sql_info_->not_param_index_.add_member(ctx.sql_info_->total_++))) {
SQL_PC_LOG(WARN, "failed to add member", K(ctx.sql_info_->total_), K(ret));
} else if (OB_FAIL(add_varchar_charset(root, *ctx.sql_info_))) {
SQL_PC_LOG(WARN, "fail to add varchar charset", K(ret));
} else {
if (ctx.sql_info_->need_check_fp_) {
ObPCParseInfo p_info;
p_info.param_idx_ = ctx.sql_info_->total_ - 1;
p_info.flag_ = NOT_PARAM;
p_info.raw_text_pos_ = root->sql_str_off_;
if (root->sql_str_off_ == -1) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("invlid str off", K(lbt()), K(ctx.tree_),
K(root->raw_param_idx_), K(get_type_name(root->type_)),
K(session_info.get_current_query_string()),
"result_tree_", SJ(ObParserResultPrintWrapper(*ctx.top_node_)));
}
if (OB_FAIL(ret)) {
// do nithing
} else if (OB_FAIL(ctx.sql_info_->parse_infos_.push_back(p_info))) {
SQL_PC_LOG(WARN, "fail to push parser info", K(ret));
}
}
}
} // for end
} else {
// do nothing
}
}
}
}
} // for end
if (is_project_list_scope) {
ctx.is_project_list_scope_ = false;
}
}
return ret;
}
int ObSqlParameterization::check_and_generate_param_info(const ObIArray<ObPCParam *> &raw_params,
const SqlInfo &sql_info,
ObIArray<ObPCParam *> &special_params)
{
int ret = OB_SUCCESS;
if (sql_info.total_ != raw_params.count()) {
ret = OB_NOT_SUPPORTED;
if (sql_info.need_check_fp_) {
SQL_PC_LOG(ERROR, "const number of fast parse and normal parse is different",
"fast_parse_const_num", raw_params.count(),
"normal_parse_const_num", sql_info.total_);
}
}
if (OB_FAIL(ret)) {
} else {
ObPCParam *pc_param = NULL;
for (int32_t i = 0; OB_SUCC(ret) && i < raw_params.count(); i ++) {
//not param 和neg param不可能是同一个param, 在transform_tree时已保证
pc_param = raw_params.at(i);
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (OB_ISNULL(pc_param->node_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(pc_param->node_), K(ret));
} else if (sql_info.not_param_index_.has_member(i)) { //not param
pc_param->flag_ = NOT_PARAM;
if (OB_FAIL(special_params.push_back(pc_param))) {
SQL_PC_LOG(WARN, "fail to push item to array", K(ret));
}
} else if (sql_info.neg_param_index_.has_member(i)) {//neg param
//如果是T_VARCHAR则不需要记录为负数, ?sql也不需要合并-?
if (T_VARCHAR == pc_param->node_->type_) {
//do nothing
} else {
pc_param->flag_ = NEG_PARAM;
if (OB_FAIL(special_params.push_back(pc_param))) {
SQL_PC_LOG(WARN, "fail to push item to array", K(ret));
}
}
} else if (sql_info.trans_from_minus_index_.has_member(i)) {
pc_param->flag_ = TRANS_NEG_PARAM;
if (OB_FAIL(special_params.push_back(pc_param))) {
SQL_PC_LOG(WARN, "failed to push back item to array", K(ret));
}
} else {
pc_param->flag_ = NORMAL_PARAM;
}
} // for end
if (sql_info.need_check_fp_) {
// do nothing
int last_pos = -1;
int last_param_idx = -1;
for (int i = 0; OB_SUCC(ret) && i < sql_info.parse_infos_.count(); i++) {
if (last_pos > sql_info.parse_infos_.at(i).raw_text_pos_ ||
last_param_idx > sql_info.parse_infos_.at(i).param_idx_) {
ret = OB_NOT_SUPPORTED;
SQL_PC_LOG(ERROR, "invalid parse order", K(last_param_idx), K(last_pos),
K(sql_info.parse_infos_.at(i).raw_text_pos_),
K(sql_info.parse_infos_.at(i).param_idx_),
K(sql_info.parse_infos_), K(ret));
} else {
last_pos = sql_info.parse_infos_.at(i).raw_text_pos_;
last_param_idx = sql_info.parse_infos_.at(i).param_idx_;
}
}
}
}
return ret;
}
//长路径sql参数化
int ObSqlParameterization::parameterize_syntax_tree(common::ObIAllocator &allocator,
bool is_transform_outline,
ObPlanCacheCtx &pc_ctx,
ParseNode *tree,
ParamStore &params,
ObCollationType cs_type)
{
int ret = OB_SUCCESS;
SqlInfo sql_info;
bool need_parameterized = false;
SQL_EXECUTION_MODE mode = get_sql_execution_mode(pc_ctx);
ObMaxConcurrentParam::FixParamStore fix_param_store(OB_MALLOC_NORMAL_BLOCK_SIZE,
ObWrapperAllocator(&allocator));
ObSQLSessionInfo *session = NULL;
ObSEArray<ObPCParam *, OB_PC_SPECIAL_PARAM_COUNT> special_params;
ObSEArray<ObString, 4> user_var_names;
int tmp_ret = OB_SUCCESS;
tmp_ret = OB_E(EventTable::EN_SQL_PARAM_FP_NP_NOT_SAME_ERROR) OB_SUCCESS;
if (OB_SUCCESS != tmp_ret) {
sql_info.need_check_fp_ = true;
}
int64_t reserved_cnt = 0;
if (OB_ISNULL(session = pc_ctx.exec_ctx_.get_my_session())) {
ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(ERROR, "got session is NULL", K(ret));
} else if (is_prepare_mode(mode)
|| is_transform_outline
) {
// if so, faster parser is needed
// otherwise, fast parser has been done before
pc_ctx.fp_result_.reset();
FPContext fp_ctx(cs_type);
fp_ctx.enable_batched_multi_stmt_ = pc_ctx.sql_ctx_.handle_batched_multi_stmt();
fp_ctx.sql_mode_ = session->get_sql_mode();
fp_ctx.is_udr_mode_ = pc_ctx.is_rewrite_sql_;
fp_ctx.def_name_ctx_ = pc_ctx.def_name_ctx_;
if (OB_FAIL(fast_parser(allocator,
fp_ctx,
pc_ctx.raw_sql_,
pc_ctx.fp_result_))) {
SQL_PC_LOG(WARN, "fail to fast parser", K(ret));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (FALSE_IT(reserved_cnt = pc_ctx.fp_result_.raw_params_.count())) {
} else if (!is_execute_mode(mode)
&& (OB_FAIL(params.reserve(reserved_cnt)) // Reserve array to avoid extending
|| OB_FAIL(sql_info.param_charset_type_.reserve(reserved_cnt))
|| OB_FAIL(sql_info.fixed_param_idx_.reserve(reserved_cnt)))) {
LOG_WARN("failed to reserve array", K(ret));
} else if (OB_FAIL(transform_syntax_tree(allocator,
*session,
is_execute_mode(mode) ? NULL : &pc_ctx.fp_result_.raw_params_,
tree,
sql_info,
params,
is_prepare_mode(mode) ? NULL : &pc_ctx.select_item_param_infos_,
fix_param_store,
is_transform_outline,
mode,
&pc_ctx.fixed_param_info_list_))) {
if (OB_NOT_SUPPORTED != ret) {
SQL_PC_LOG(WARN, "fail to normal parameterized parser tree", K(ret));
}
} else {
need_parameterized = (!(PC_PS_MODE == pc_ctx.mode_ || PC_PL_MODE == pc_ctx.mode_)
|| (is_prepare_mode(mode) && sql_info.ps_need_parameterized_));
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(get_related_user_vars(tree, user_var_names))) {
LOG_WARN("failed to get related session vars", K(ret));
} else if (OB_FAIL(pc_ctx.sql_ctx_.set_related_user_var_names(user_var_names, allocator))) {
LOG_WARN("failed to set related user var names for sql ctx", K(ret));
} else if (is_execute_mode(mode)) {
if (OB_FAIL(gen_ps_not_param_var(sql_info.ps_not_param_offsets_, params, pc_ctx))) {
SQL_PC_LOG(WARN, "fail to gen ps not param var", K(ret));
} else if (OB_FAIL(construct_no_check_type_params(sql_info.no_check_type_offsets_,
sql_info.need_check_type_param_offsets_,
params))) {
SQL_PC_LOG(WARN, "fail to construct no check type params", K(ret));
}
} else if (need_parameterized) {
if (OB_FAIL(check_and_generate_param_info(pc_ctx.fp_result_.raw_params_,
sql_info,
special_params))) {
if (OB_NOT_SUPPORTED != ret) {
SQL_PC_LOG(WARN, "fail to check and generate param info", K(ret));
} else if (sql_info.need_check_fp_) {
SQL_PC_LOG(INFO, "print tree", K(session->get_current_query_string()), "result_tree_", SJ(ObParserResultPrintWrapper(*tree)));
} else {
// do nothing
}
} else if (OB_FAIL(gen_special_param_info(sql_info, pc_ctx))) {
SQL_PC_LOG(WARN, "fail to gen special param info", K(ret));
} else {
// do nothing
}
if (OB_SUCC(ret)) {
char *buf = NULL;
int32_t pos = 0;
buf = (char *)allocator.alloc(pc_ctx.raw_sql_.length());
if (NULL == buf) {
SQL_PC_LOG(WARN, "fail to alloc buf", K(pc_ctx.raw_sql_.length()));
ret = OB_ALLOCATE_MEMORY_FAILED;
} else if (OB_FAIL(construct_sql(pc_ctx.fp_result_.pc_key_.name_, special_params, buf, pc_ctx.raw_sql_.length(), pos))) {
SQL_PC_LOG(WARN, "fail to construct_sql", K(ret));
} else if (is_prepare_mode(mode) && OB_FAIL(transform_neg_param(pc_ctx.fp_result_.raw_params_))) {
SQL_PC_LOG(WARN, "fail to transform_neg_param", K(ret));
} else {
pc_ctx.sql_ctx_.spm_ctx_.bl_key_.constructed_sql_.assign_ptr(buf, pos);
pc_ctx.ps_need_parameterized_ = sql_info.ps_need_parameterized_;
pc_ctx.normal_parse_const_cnt_ = sql_info.total_;
}
}
}
return ret;
}
//生成not param info信息及index信息
int ObSqlParameterization::gen_special_param_info(SqlInfo &sql_info, ObPlanCacheCtx &pc_ctx)
{
int ret = OB_SUCCESS;
ParseNode *raw_param = NULL;
NotParamInfo np_info;
pc_ctx.not_param_info_.set_capacity(sql_info.not_param_index_.num_members());
for (int32_t i = 0; OB_SUCC(ret) && i < pc_ctx.fp_result_.raw_params_.count(); i ++) {
if (OB_ISNULL(pc_ctx.fp_result_.raw_params_.at(i))) {
ret = OB_INVALID_ARGUMENT;
} else if (NULL == (raw_param = pc_ctx.fp_result_.raw_params_.at(i)->node_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (sql_info.not_param_index_.has_member(i)) { //not param
np_info.reset();
np_info.idx_ = i;
np_info.raw_text_ = ObString(raw_param->text_len_, raw_param->raw_text_);
if (OB_FAIL(pc_ctx.not_param_info_.push_back(np_info))) {
SQL_PC_LOG(WARN, "fail to push item to array", K(ret));
}
}
} // for end
if (OB_SUCC(ret)) {
if (OB_FAIL(pc_ctx.not_param_index_.add_members2(sql_info.not_param_index_))) {
LOG_WARN("fail to add not param index members", K(ret));
} else if (OB_FAIL(pc_ctx.neg_param_index_.add_members2(sql_info.neg_param_index_))) {
LOG_WARN("fail to add neg param index members", K(ret));
} else if (OB_FAIL(pc_ctx.neg_param_index_.add_members2(sql_info.trans_from_minus_index_))) {
LOG_WARN("failed to add trans from minus index members", K(ret));
} else if (OB_FAIL(pc_ctx.param_charset_type_.assign(sql_info.param_charset_type_))) {
LOG_WARN("fail to assign param charset type", K(ret));
} else if (OB_FAIL(pc_ctx.fixed_param_idx_.assign(sql_info.fixed_param_idx_))) {
LOG_WARN("fail to assign fixed param idx", K(ret));
} else if (OB_FAIL(pc_ctx.must_be_positive_index_.add_members2(sql_info.must_be_positive_index_))) {
LOG_WARN("failed to add bitset members", K(ret));
} else {
// do nothing
}
}
return ret;
}
int ObSqlParameterization::gen_ps_not_param_var(const ObIArray<int64_t> &offsets,
ParamStore &params,
ObPlanCacheCtx &pc_ctx)
{
int ret = OB_SUCCESS;
pc_ctx.not_param_var_.set_capacity(offsets.count());
for (int i = 0; OB_SUCC(ret) && i < offsets.count(); ++i) {
const int64_t offset = offsets.at(i);
PsNotParamInfo ps_not_param_var;
ps_not_param_var.idx_ = offset;
if (offset >= params.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("offset should not oversize param size", K(ret), K(offset), K(params.count()));
} else {
ps_not_param_var.ps_param_ = params.at(offset);
if (OB_FAIL(pc_ctx.not_param_var_.push_back(ps_not_param_var))) {
LOG_WARN("fail to push item to array", K(ret));
} else if (OB_FAIL(pc_ctx.not_param_index_.add_member(offset))) {
LOG_WARN("add member failed", K(ret), K(offset));
}
}
}
return ret;
}
int ObSqlParameterization::construct_no_check_type_params(const ObIArray<int64_t> &no_check_type_offsets,
const ObBitSet<> &need_check_type_offsets,
ParamStore &params)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < no_check_type_offsets.count(); i++) {
const int64_t offset = no_check_type_offsets.at(i);
if (offset < 0 || offset >= params.count()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid offset", K(ret), K(offset), K(params.count()));
} else if (need_check_type_offsets.has_member(offset)) {
// do nothing
} else if (!params.at(offset).is_ext()) { // extend type need to be checked
params.at(offset).set_need_to_check_type(false);
} else {
// real type do not need to be checked
params.at(offset).set_need_to_check_extend_type(false);
}
} // for end
LOG_DEBUG("ps obj param infos", K(params), K(no_check_type_offsets), K(need_check_type_offsets));
return ret;
}
int ObSqlParameterization::transform_neg_param(ObIArray<ObPCParam *> &pc_params)
{
int ret = OB_SUCCESS;
ObPCParam *pc_param = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < pc_params.count(); i ++) {
pc_param = pc_params.at(i);
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (TRANS_NEG_PARAM == pc_param->flag_) {
int64_t tmp_pos = 0;
for (; tmp_pos < pc_param->node_->str_len_ && isspace(pc_param->node_->str_value_[tmp_pos]); tmp_pos++);
if (OB_UNLIKELY(tmp_pos >= pc_param->node_->str_len_)) {
int ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(tmp_pos), K(pc_param->node_->str_len_), K(ret));
} else {
if ('-' != pc_param->node_->str_value_[tmp_pos]) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expected neg sign here", K(tmp_pos), K(ObString(pc_param->node_->str_len_,
pc_param->node_->str_value_)));
} else {
tmp_pos += 1;
for (; tmp_pos < pc_param->node_->str_len_ && isspace(pc_param->node_->str_value_[tmp_pos]); tmp_pos++);
}
if (OB_SUCC(ret)) {
pc_param->node_->str_value_ += tmp_pos;
pc_param->node_->str_len_ -= tmp_pos;
if (T_NUMBER != pc_param->node_->type_ && pc_param->node_->value_ < 0) {
pc_param->node_->value_ = 0 - pc_param->node_->value_;
}
}
}
}
}
return ret;
}
int ObSqlParameterization::construct_not_param(const ObString &no_param_sql,
ObPCParam *pc_param,
char *buf,
int32_t buf_len,
int32_t &pos,
int32_t &idx)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else {
int32_t len = (int32_t)pc_param->node_->pos_ - idx;
if (len > buf_len - pos) {
ret = OB_BUF_NOT_ENOUGH;
} else if (len > 0) {
//copy text
MEMCPY(buf + pos, no_param_sql.ptr() + idx, len);
idx = (int32_t)pc_param->node_->pos_ + 1;
pos += len;
//copy raw param
MEMCPY(buf + pos, pc_param->node_->raw_text_, pc_param->node_->text_len_);
pos += (int32_t)pc_param->node_->text_len_;
}
}
return ret;
}
int ObSqlParameterization::construct_neg_param(const ObString &no_param_sql,
ObPCParam *pc_param,
char *buf,
int32_t buf_len,
int32_t &pos,
int32_t &idx)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else {
int32_t len = (int32_t)pc_param->node_->pos_ - idx;
if (len > buf_len - pos) {
ret = OB_BUF_NOT_ENOUGH;
} else if (len > 0) {
MEMCPY(buf + pos, no_param_sql.ptr() + idx, len);
pos += len;
}
if (OB_SUCC(ret)) {
idx = (int32_t)pc_param->node_->pos_ + 1;
buf[pos++] = '?';
}
}
return ret;
}
int ObSqlParameterization::construct_trans_neg_param(const ObString &no_param_sql,
ObPCParam *pc_param,
char *buf,
int32_t buf_len,
int32_t &pos,
int32_t &idx)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else {
int32_t len = (int32_t)pc_param->node_->pos_ - idx;
if (len > buf_len - pos) {
ret = OB_BUF_NOT_ENOUGH;
} else if (len > 0) {
MEMCPY(buf + pos, no_param_sql.ptr() + idx, len);
pos += len;
}
if (OB_SUCC(ret)) {
// for 'select * from t where a - 1 = 2', the statement is 'select * from t where a - ? = ?'
// so we need fill spaces between '-' and '?', so here it is
buf[pos++] = '-';
int64_t tmp_pos = 0;
for (; tmp_pos < pc_param->node_->str_len_ && isspace(pc_param->node_->str_value_[tmp_pos]); tmp_pos++);
if (OB_UNLIKELY(tmp_pos >= pc_param->node_->str_len_)) {
int ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(tmp_pos), K(pc_param->node_->str_len_), K(ret));
} else {
if ('-' != pc_param->node_->str_value_[tmp_pos]) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expected neg sign here", K(tmp_pos), K(ObString(pc_param->node_->str_len_,
pc_param->node_->str_value_)));
} else {
tmp_pos += 1;
for (; tmp_pos < pc_param->node_->str_len_ && isspace(pc_param->node_->str_value_[tmp_pos]); tmp_pos++) {
buf[pos++] = ' ';
}
}
if (OB_SUCC(ret)) {
buf[pos++] = '?';
idx = pc_param->node_->pos_ + 1;
}
}
}
}
return ret;
}
int ObSqlParameterization::construct_sql(const ObString &no_param_sql,
ObIArray<ObPCParam *> &pc_params,
char *buf,
int32_t buf_len,
int32_t &pos) //已存的长度
{
int ret = OB_SUCCESS;
int32_t idx = 0; //原始带?sql的偏移位置
ObPCParam *pc_param = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < pc_params.count(); i ++) {
pc_param = pc_params.at(i);
int32_t len = 0; //需要copy的text的长度
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (NOT_PARAM == pc_param->flag_) {
OZ (construct_not_param(no_param_sql, pc_param, buf, buf_len, pos, idx));
} else if (NEG_PARAM == pc_param->flag_) {
OZ (construct_neg_param(no_param_sql, pc_param, buf, buf_len, pos, idx));
} else if (TRANS_NEG_PARAM == pc_param->flag_) {
OZ (construct_trans_neg_param(no_param_sql, pc_param, buf, buf_len, pos, idx));
} else {
//do nothing
}
} //for end
if (OB_SUCCESS == ret) {
int32_t len = no_param_sql.length() - idx;
if (len > buf_len - pos) {
ret = OB_BUF_NOT_ENOUGH;
} else if (len > 0) {
MEMCPY(buf + pos, no_param_sql.ptr() + idx, len);
idx += len;
pos += len;
}
}
return ret;
}
int ObSqlParameterization::construct_sql_for_pl(const ObString &no_param_sql,
ObIArray<ObPCParam *> &pc_params,
char *buf,
int32_t buf_len,
int32_t &pos) //已存的长度
{
int ret = OB_SUCCESS;
int32_t idx = 0; //原始带?sql的偏移位置
ObPCParam *pc_param = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < pc_params.count(); i ++) {
pc_param = pc_params.at(i);
int32_t len = 0; //需要copy的text的长度
if (OB_ISNULL(pc_param)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (NOT_PARAM == pc_param->flag_) {
int32_t len = (int32_t)pc_param->node_->pos_ - idx;
if (0 == len) {
MEMCPY(buf + pos, pc_param->node_->raw_text_, pc_param->node_->text_len_);
pos += (int32_t)pc_param->node_->text_len_;
idx = (int32_t)pc_param->node_->pos_ + 1;
} else {
OZ (construct_not_param(no_param_sql, pc_param, buf, buf_len, pos, idx));
}
} else if (NEG_PARAM == pc_param->flag_) {
OZ (construct_neg_param(no_param_sql, pc_param, buf, buf_len, pos, idx));
} else if (TRANS_NEG_PARAM == pc_param->flag_) {
OZ (construct_trans_neg_param(no_param_sql, pc_param, buf, buf_len, pos, idx));
} else {
//do nothing
}
} //for end
if (OB_SUCCESS == ret) {
int32_t len = no_param_sql.length() - idx;
if (len > buf_len - pos) {
ret = OB_BUF_NOT_ENOUGH;
} else if (len > 0) {
MEMCPY(buf + pos, no_param_sql.ptr() + idx, len);
idx += len;
pos += len;
}
}
return ret;
}
bool ObSqlParameterization::need_fast_parser(const ObString &sql)
{
bool b_ret = true;
const char *stmt = sql.ptr();
int64_t len = sql.length();
int64_t leading_space_len = 0;
while (leading_space_len < len && isspace(stmt[leading_space_len])) {
++leading_space_len;
}
len -= leading_space_len;
stmt += leading_space_len;
if (len > 4 && ('s' == stmt[0] || 'S' == stmt[0]) && ('h' == stmt[1] || 'H' == stmt[1])) {
if (0 == STRNCASECMP(stmt, "show", 4)) {
b_ret = false;
}
}
return b_ret;
}
int ObSqlParameterization::fast_parser(ObIAllocator &allocator,
const FPContext &fp_ctx,
const ObString &sql,
ObFastParserResult &fp_result)
{
//UNUSED(sql_mode);
int ret = OB_SUCCESS;
int64_t param_num = 0;
char *no_param_sql_ptr = NULL;
int64_t no_param_sql_len = 0;
ParamList *p_list = NULL;
bool is_call_procedure = false;
bool is_contain_select = (sql.length() > 6 && 0 == STRNCASECMP(sql.ptr(), "select", 6));
if (!is_contain_select && (!need_fast_parser(sql)
|| (ObParser::is_pl_stmt(sql, nullptr, &is_call_procedure) && !is_call_procedure))) {
(void)fp_result.pc_key_.name_.assign_ptr(sql.ptr(), sql.length());
} else if (GCONF._ob_enable_fast_parser) {
if (OB_FAIL(ObFastParser::parse(sql, fp_ctx, allocator, no_param_sql_ptr,
no_param_sql_len, p_list, param_num, fp_result.question_mark_ctx_))) {
LOG_WARN("fast parse error", K(param_num),
K(ObString(no_param_sql_len, no_param_sql_ptr)), K(sql));
}
if (OB_SUCC(ret)) {
(void)fp_result.pc_key_.name_.assign_ptr(no_param_sql_ptr, no_param_sql_len);
if (param_num > 0) {
ObPCParam *pc_param = NULL;
char *ptr = (char *)allocator.alloc(param_num * sizeof(ObPCParam));
fp_result.raw_params_.reset();
fp_result.raw_params_.set_allocator(&allocator);
fp_result.raw_params_.set_capacity(param_num);
if (OB_ISNULL(ptr)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
SQL_PC_LOG(WARN, "fail to alloc memory for pc param", K(ret), K(ptr));
}
for (int64_t i = 0; OB_SUCC(ret) && i < param_num && NULL != p_list; i++) {
pc_param = new(ptr)ObPCParam();
ptr += sizeof(ObPCParam);
pc_param->node_ = p_list->node_;
if (OB_FAIL(fp_result.raw_params_.push_back(pc_param))) {
SQL_PC_LOG(WARN, "fail to push into params", K(ret));
} else {
p_list = p_list->next_;
}
} // for end
} else { /*do nothing*/}
}
} else {
ObParser parser(allocator, fp_ctx.sql_mode_, fp_ctx.conn_coll_);
SMART_VAR(ParseResult, parse_result) {
if (OB_FAIL(parser.parse(sql, parse_result, FP_MODE, fp_ctx.enable_batched_multi_stmt_))) {
SQL_PC_LOG(WARN, "fail to fast parser", K(sql), K(ret));
} else {
(void)fp_result.pc_key_.name_.assign_ptr(parse_result.no_param_sql_, parse_result.no_param_sql_len_);
int64_t param_num = parse_result.param_node_num_;
//copy raw params
if (param_num > 0) {
ObPCParam *pc_param = NULL;
ParamList *p_list = parse_result.param_nodes_;
char *ptr = (char *)allocator.alloc(param_num * sizeof(ObPCParam));
fp_result.raw_params_.set_allocator(&allocator);
fp_result.raw_params_.set_capacity(param_num);
if (OB_ISNULL(ptr)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
SQL_PC_LOG(WARN, "fail to alloc memory for pc param", K(ret), K(ptr));
}
for (int64_t i = 0;
OB_SUCC(ret) && i < param_num && NULL != p_list;//当p_list = NULL,表示链表结束
i++) {
pc_param = new(ptr)ObPCParam();
ptr += sizeof(ObPCParam);
pc_param->node_ = p_list->node_;
if (OB_FAIL(fp_result.raw_params_.push_back(pc_param))) {
SQL_PC_LOG(WARN, "fail to push into params", K(ret));
} else {
p_list = p_list->next_;
}
} // for end
} else { /*do nothing*/}
}
}
}
return ret;
}
//used for outline
int ObSqlParameterization::raw_fast_parameterize_sql(ObIAllocator &allocator,
const ObSQLSessionInfo &session,
const ObString &sql,
ObString &no_param_sql,
ObIArray<ObPCParam *> &raw_params,
ParseMode parse_mode)
{
int ret = OB_SUCCESS;
ObParser parser(allocator, session.get_sql_mode(), session.get_local_collation_connection());
ParseResult parse_result;
NG_TRACE(pc_fast_parse_start);
if (OB_FAIL(parser.parse(sql,
parse_result,
parse_mode,
false))) {
SQL_PC_LOG(WARN, "fail to parse query", K(ret));
}
NG_TRACE(pc_fast_parse_end);
if (OB_SUCC(ret)) {
no_param_sql.assign(parse_result.no_param_sql_, parse_result.no_param_sql_len_);
}
if (OB_SUCC(ret)) {
ParamList *param = parse_result.param_nodes_;
for (int32_t i = 0;
OB_SUCC(ret) && i < parse_result.param_node_num_ && NULL != param;//当param = NULL,表示链表结束
i ++) {
void *ptr = allocator.alloc(sizeof(ObPCParam));
if (OB_ISNULL(ptr)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
SQL_PC_LOG(ERROR, "fail to alloc memory for pc param", K(ret), K(ptr));
} else {
ObPCParam *pc_param = new(ptr)ObPCParam();
pc_param->node_ = param->node_;
if (OB_FAIL(raw_params.push_back(pc_param))) {
SQL_PC_LOG(WARN, "fail to push into params", K(ret));
} else {
param = param->next_;
}
}
} // for end
}
SQL_PC_LOG(DEBUG, "after raw fp", K(parse_result.param_node_num_));
return ret;
}
int ObSqlParameterization::insert_neg_sign(ObIAllocator &alloc_buf, ParseNode *node)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(node)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(node), K(ret));
} else if (T_INT != node->type_ && T_DOUBLE != node->type_ && T_FLOAT != node->type_ && T_NUMBER != node->type_) {
ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(WARN, "invalid neg digit type", K(node->type_), K(ret));
} else {
if (T_INT == node->type_) {
node->value_ = -node->value_;
}
char *new_str = static_cast<char *>(parse_malloc(node->str_len_ + 2, &alloc_buf));
char *new_raw_text = static_cast<char *>(parse_malloc(node->text_len_ + 2, &alloc_buf));
if (OB_ISNULL(new_str) || OB_ISNULL(new_raw_text)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
SQL_PC_LOG(ERROR, "parse_strdup failed", K(ret), K(new_raw_text), K(new_str));
} else {
new_str[0] = '-';
new_raw_text[0] = '-';
MEMMOVE(new_str+1, node->str_value_, node->str_len_);
MEMMOVE(new_raw_text+1, node->raw_text_, node->text_len_);
new_str[node->str_len_ + 1] = '\0';
new_raw_text[node->text_len_ + 1] = '\0';
node->str_value_ = new_str;
node->raw_text_ = new_raw_text;
node->str_len_++;
node->text_len_++;
}
}
return ret;
}
int ObSqlParameterization::add_param_flag(const ParseNode *node, SqlInfo &sql_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(node)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (1 == node->is_neg_) {
if (OB_FAIL(sql_info.neg_param_index_.add_member(sql_info.total_))) {
SQL_PC_LOG(WARN, "failed to add neg param index", K(sql_info.total_), K(ret));
}
} else if (node->is_trans_from_minus_) {
if (OB_FAIL(sql_info.trans_from_minus_index_.add_member(sql_info.total_))) {
SQL_PC_LOG(WARN, "failed to add trans_from_minus index", K(sql_info.total_), K(ret));
}
} else {
// do nothing
}
return ret;
}
int ObSqlParameterization::add_not_param_flag(const ParseNode *node, SqlInfo &sql_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(node)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else if (T_QUESTIONMARK == node->type_) {
if (OB_FAIL(sql_info.ps_not_param_offsets_.push_back(node->value_))) {
LOG_WARN("pushback offset failed", K(node->value_));
} else if (OB_FAIL(sql_info.not_param_index_.add_member(node->value_))) {
SQL_PC_LOG(WARN, "failed to add member", K(node->value_));
}
} else if (T_CAST_ARGUMENT == node->type_ //如果是cast类型，则需要添加N个cast节点对应的常数, 因为正常parse不识别为常量, 但fast parse时会识别为常量
|| T_COLLATION == node->type_
|| T_NULLX_CLAUSE == node->type_ // deal null clause on json expr
|| T_WEIGHT_STRING_LEVEL_PARAM == node->type_) {
for (int i = 0; OB_SUCC(ret) && i < node->param_num_; ++i) {
if (OB_FAIL(sql_info.not_param_index_.add_member(sql_info.total_++))) {
SQL_PC_LOG(WARN, "failed to add member", K(sql_info.total_));
} else if (OB_FAIL(add_varchar_charset(node, sql_info))) {
SQL_PC_LOG(WARN, "fail to add varchar charset", K(ret));
}
if (sql_info.need_check_fp_) {
ObPCParseInfo p_info;
p_info.param_idx_ = sql_info.total_ - 1;
p_info.flag_ = NOT_PARAM;
p_info.raw_text_pos_ = node->sql_str_off_;
if (node->sql_str_off_ == -1) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("invlid str off", K(lbt()), K(node),
K(node->raw_param_idx_), K(get_type_name(node->type_)));
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(sql_info.parse_infos_.push_back(p_info))) {
SQL_PC_LOG(WARN, "fail to push parser info", K(ret));
}
}
}
} else {
if (OB_FAIL(sql_info.not_param_index_.add_member(sql_info.total_++))) {
SQL_PC_LOG(WARN, "failed to add member", K(sql_info.total_));
} else if (OB_FAIL(add_varchar_charset(node, sql_info))) {
SQL_PC_LOG(WARN, "fail to add varchar charset", K(ret));
}
if (sql_info.need_check_fp_) {
ObPCParseInfo p_info;
p_info.param_idx_ = sql_info.total_ - 1;
p_info.flag_ = NOT_PARAM;
p_info.raw_text_pos_ = node->sql_str_off_;
if (node->sql_str_off_ == -1) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("invlid str off", K(lbt()), K(node),
K(node->raw_param_idx_), K(get_type_name(node->type_)));
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(sql_info.parse_infos_.push_back(p_info))) {
SQL_PC_LOG(WARN, "fail to push parser info", K(ret));
}
}
}
return ret;
}
//T_FUN_SYS类型函数
//根据mark_arr将func中参数节点标记为该节点及其子节点不能参数化
int ObSqlParameterization::mark_args(ParseNode *arg_tree,
const bool *mark_arr,
int64_t arg_num,
SqlInfo &sql_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(arg_tree) || OB_ISNULL(mark_arr)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret), K(arg_tree));
} else if (OB_ISNULL(arg_tree->children_)
|| arg_num != arg_tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret),
K(arg_tree->type_), K(arg_tree->children_), K(arg_tree->num_child_));
} else {
sql_info.ps_need_parameterized_ = false;
for (int64_t i = 0; OB_SUCC(ret) && i < arg_num; i++) {
if (true == mark_arr[i]) {
if (OB_ISNULL(arg_tree->children_[i])) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret), K(arg_tree->children_[i]));
} else {
arg_tree->children_[i]->is_tree_not_param_ = true;
}
}
}
}
return ret;
}
// 对于不能参数化需要特殊标记的节点进行标记, 一般是不能直接通过节点类型判别的节点可在该函数中进行标记
// Mark those special nodes that cannot be parameterized.
// After mark this node, it has following mechanism:
// If a node is marked as cannot be parameterized,
// CUREENT NODE AND ALL NODES OF IT'S SUBTREE cannot be parameterized.
int ObSqlParameterization::mark_tree(ParseNode *tree ,SqlInfo &sql_info)
{
int ret = OB_SUCCESS;
if (NULL == tree) {
//do nothing
} else if (T_FUN_SYS == tree->type_) {
ParseNode **node = tree->children_;//node[0] : func name, node[1]: arg list
if (2 != tree->num_child_) {
//do nothing 如果不是fun_name和arg_list则不在需要标记的考虑内
} else if (OB_ISNULL(node) || OB_ISNULL(node[0]) || OB_ISNULL(node[1])) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret), K(node));
} else {
ObString func_name(node[0]->str_len_, node[0]->str_value_);
if ((0 == func_name.case_compare("USERENV")
|| 0 == func_name.case_compare("UNIX_TIMESTAMP"))
&& (1 == node[1]->num_child_)) {
// USERENV函数的返回类型是由参数的具体值来决定，如果参数化后，无法拿到具体值，所以暂时不进行参数化
// UNIX_TIMESTAMP(param_str)，结果的精度和param_str有关，不能参数化
const int64_t ARGS_NUMBER_ONE = 1;
bool mark_arr[ARGS_NUMBER_ONE] = {1}; //0表示参数化, 1 表示不参数化
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_ONE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark arg", K(ret));
}
} else if ((0 == func_name.case_compare("substr")
|| 0 == func_name.case_compare("extract_xml"))
&& (3 == node[1]->num_child_)) {
const int64_t ARGS_NUMBER_THREE = 3;
bool mark_arr[ARGS_NUMBER_THREE] = {0, 1, 1}; //0表示参数化, 1 表示不参数化
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_THREE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark arg", K(ret));
}
} else if (0 == func_name.case_compare("xmlserialize")
&& (10 == node[1]->num_child_)) {
const int64_t ARGS_NUMBER_TEN = 10;
bool mark_arr[ARGS_NUMBER_TEN] = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1}; //0表示参数化, 1 表示不参数化
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_TEN, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark weight_string arg", K(ret));
}
}else if (0 == func_name.case_compare("weight_string")
&& (5 == node[1]->num_child_)) {
const int64_t ARGS_NUMBER_FIVE = 5;
bool mark_arr[ARGS_NUMBER_FIVE] = {0, 1, 1, 1, 1}; //0表示参数化, 1 表示不参数化
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_FIVE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark weight_string arg", K(ret));
}
} else if ((0==func_name.case_compare("convert")
|| (0==func_name.case_compare("char")))
&& (2 == node[1]->num_child_)) {
const int64_t ARGS_NUMBER_TWO = 2;
bool mark_arr[ARGS_NUMBER_TWO] = {0, 1};
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_TWO, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
} else if ((0 == func_name.case_compare("str_to_date") // STR_TO_DATE(str,format)
|| 0 == func_name.case_compare("date_format") //DATE_FORMAT(date,format)
|| 0 == func_name.case_compare("from_unixtime")//FROM_UNIXTIME(unix_timestamp), FROM_UNIXTIME(unix_timestamp,format)
|| 0 == func_name.case_compare("round") //ROUND(X), ROUND(X,D)
|| 0 == func_name.case_compare("left") // the length of result should be set with the value of the second param
|| 0 == func_name.case_compare("substr")
|| 0 == func_name.case_compare("dbms_lob_convert_clob_charset")
|| 0 == func_name.case_compare("truncate")) // truncate结果的精度需要根据第二个参数进行推导，所以不能参数化
&& (2 == node[1]->num_child_)) {
const int64_t ARGS_NUMBER_TWO = 2;
bool mark_arr[ARGS_NUMBER_TWO] = {0, 1};
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_TWO, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark arg", K(ret));
}
} else if ((0 == func_name.case_compare("name_const"))
&& (2 == node[1]->num_child_)) {
const int64_t ARGS_NUMBER_TWO = 2;
bool mark_arr[ARGS_NUMBER_TWO] = {1, 0};
if (OB_FAIL(mark_args(node[1], mark_arr, ARGS_NUMBER_TWO, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark arg", K(ret));
}
} else if ((0 == func_name.case_compare("concat")) && 1 == node[0]->reserved_) {
sql_info.ps_need_parameterized_ = false;
}
}
} else if (T_OP_LIKE == tree->type_) {
if (3 == tree->num_child_) { // child[0] like child[1] escape child[2]
const int64_t ARGS_NUMBER_THREE = 3;
bool mark_arr[ARGS_NUMBER_THREE] = {0, 1, 1}; //0表示参数化, 1 表示不参数化
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_THREE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
}
} else if (T_OP_IS == tree->type_ || T_OP_IS_NOT == tree->type_) {
if (tree->num_child_ == 2) {
const int64_t ARGS_NUMBER_TWO = 2;
bool mark_arr[ARGS_NUMBER_TWO] = {0,1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_TWO, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
} else { /*do nothing*/ }
} else if(T_FUN_SYS_JSON_VALUE == tree->type_) {
if (9 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json value expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_NINE = 9;
bool mark_arr[ARGS_NUMBER_NINE] = {0, 1, 1, 1, 1, 1, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_NINE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
}
} else if(T_FUN_SYS_JSON_OBJECT == tree->type_) {
if (5 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json object expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_FIVE = 5;
bool mark_arr[ARGS_NUMBER_FIVE] = {1, 1, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_FIVE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
}
} else if(T_FUN_SYS_IS_JSON == tree->type_) {
if (5 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument num for IS json", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_FIVE = 5;
bool mark_arr[ARGS_NUMBER_FIVE] = {0, 1, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_FIVE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
}
} else if(T_FUN_SYS_JSON_QUERY == tree->type_) {
if (10 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json query expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_TEN = 10;
bool mark_arr[ARGS_NUMBER_TEN] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; // json doc type will affect returning type,
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_TEN, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
}
} else if(T_FUN_SYS_JSON_EXISTS == tree->type_) {
if (5 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument num for json_exists", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_FIVE = 5;
bool mark_arr[ARGS_NUMBER_FIVE] = {0, 0, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_FIVE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark json_exists arg", K(ret));
}
}
} else if(T_FUN_SYS_JSON_EQUAL == tree->type_) {
if (3 < tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json query expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_THREE = 3;
bool mark_arr[ARGS_NUMBER_THREE] = {0, 0, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_THREE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark substr arg", K(ret));
}
}
} else if(T_FUN_SYS_JSON_ARRAY == tree->type_) {
if (4 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json array expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_FOUR = 4;
bool mark_arr[ARGS_NUMBER_FOUR] = {0, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_FOUR, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark json array arg", K(ret));
}
}
} else if(T_FUN_SYS_JSON_MERGE_PATCH == tree->type_) {
if (7 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json mergepatch expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_SEVEN = 7;
bool mark_arr[ARGS_NUMBER_SEVEN] = {0, 0, 1, 1, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_SEVEN, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark json mergepatch arg", K(ret));
}
}
} else if (T_JSON_TABLE_EXPRESSION == tree->type_) {
if (5 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid json mergepatch expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_FIVE = 5;
bool mark_arr[ARGS_NUMBER_FIVE] = {0, 1, 1, 1, 1};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_FIVE, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark json mergepatch arg", K(ret));
}
}
} else if (T_FUN_SYS_TREAT == tree->type_) {
if (2 != tree->num_child_) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid treat expr argument", K(ret), K(tree->num_child_));
} else {
const int64_t ARGS_NUMBER_TWO = 2;
bool mark_arr[ARGS_NUMBER_TWO] = {1, 0};
if (OB_FAIL(mark_args(tree, mark_arr, ARGS_NUMBER_TWO, sql_info))) {
SQL_PC_LOG(WARN, "fail to mark treat arg", K(ret));
}
}
} else { /*do nothing*/ }
return ret;
}
int ObSqlParameterization::add_varchar_charset(const ParseNode *node, SqlInfo &sql_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(node)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(node));
} else if (T_VARCHAR == node->type_
&& NULL != node->children_
&& NULL != node->children_[0]
&& T_CHARSET == node->children_[0]->type_) {
ObString charset(node->children_[0]->str_len_,
node->children_[0]->str_value_);
ObCharsetType charset_type = CHARSET_INVALID;
if (CHARSET_INVALID == (charset_type =
ObCharset::charset_type(charset.trim()))) {
ret = OB_ERR_UNKNOWN_CHARSET;
LOG_USER_ERROR(OB_ERR_UNKNOWN_CHARSET, charset.length(), charset.ptr());
} else if (OB_FAIL(sql_info.param_charset_type_.push_back(charset_type))) {
SQL_PC_LOG(WARN, "fail to add charset type", K(ret));
}
} else if (OB_FAIL(sql_info.param_charset_type_.push_back(CHARSET_INVALID))) {
SQL_PC_LOG(WARN, "fail to add charset type", K(ret));
}
return ret;
}
int ObSqlParameterization::get_related_user_vars(const ParseNode *tree, common::ObIArray<common::ObString> &user_vars)
{
int ret = OB_SUCCESS;
ObString var_str;
if (tree == NULL) {
// do nothing
} else {
if (T_USER_VARIABLE_IDENTIFIER == tree -> type_) {
if (OB_ISNULL(tree -> str_value_) || tree -> str_len_ <= 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tree -> str_value_), K(tree -> str_len_));
} else {
var_str.assign_ptr(tree -> str_value_, static_cast<int32_t>(tree -> str_len_));
if (OB_FAIL(user_vars.push_back(var_str))) {
LOG_WARN("failed to push back user variable", K(ret));
}
}
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < tree -> num_child_; i++) {
if (OB_ISNULL(tree -> children_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(tree -> children_), K(ret));
} else if (OB_FAIL(SMART_CALL(get_related_user_vars(tree -> children_[i], user_vars)))) {
LOG_WARN("failed to get related user vars", K(ret), K(tree -> children_[i]), K(i));
}
}
}
}
if (OB_FAIL(ret)) {
user_vars.reset();
}
return ret;
}
int ObSqlParameterization::get_select_item_param_info(const common::ObIArray<ObPCParam *> &raw_params,
ParseNode *tree,
SelectItemParamInfoArray *select_item_param_infos)
{
int ret = OB_SUCCESS;
SelectItemParamInfo param_info;
ObString org_field_name;
int64_t expr_pos = tree->raw_sql_offset_;
int64_t buf_len = SelectItemParamInfo::PARAMED_FIELD_BUF_LEN;
ObSEArray<TraverseStackFrame, 64> stack_frames;
if (T_PROJECT_STRING != tree->type_ || OB_ISNULL(tree->children_) || tree->num_child_ <= 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(tree->type_), K(tree->children_), K(tree->num_child_));
} else if (T_ALIAS == tree->children_[0]->type_
|| T_STAR == tree->children_[0]->type_) { // have alias name, or is a '*', do not need parameterized
// do nothing
} else if (OB_FAIL(stack_frames.push_back(TraverseStackFrame{tree, 0}))) {
LOG_WARN("failed to push back element", K(ret));
} else {
// start to construct paramed field name template...
if (lib::is_oracle_mode()) { // oracle要使用原始的字符串，以正确处理偏移
org_field_name.assign_ptr(tree->raw_text_, (int32_t)tree->text_len_);
} else {
org_field_name.assign_ptr(tree->str_value_, (int32_t)tree->str_len_);
}
SelectItemTraverseCtx ctx(raw_params,
tree,
org_field_name,
tree->raw_sql_offset_,
buf_len,
expr_pos,
param_info);
// 模拟函数递归操作，遍历子树
// 栈上每一个元素为 {cur_node, next_child_idx}
// 出栈操作：
// 如cur_node是的is_val_paramed_item_idx_为true，说明这是一个T_PROJECT_STRING，并且已经被遍历
// 或者T_QUESTION_MARK，或子节点都已经遍历完，出栈
//
// 入栈操作：
// 选取cur_node的第一个不为空的子节点push到堆栈中，并更新当前堆栈的next_child_idx_
for (; OB_SUCC(ret) && stack_frames.count() > 0; ) {
int64_t frame_idx = stack_frames.count() - 1;
ctx.tree_ = stack_frames.at(frame_idx).cur_node_;
if (NULL == ctx.tree_) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid null node", K(ret), K(ctx.tree_));
} else if (1 == ctx.tree_->is_val_paramed_item_idx_
|| T_QUESTIONMARK == ctx.tree_->type_
|| stack_frames.at(frame_idx).next_child_idx_ >= ctx.tree_->num_child_) {
if (T_QUESTIONMARK == ctx.tree_->type_) {
if (ctx.param_info_.name_len_ >= ctx.buf_len_) {
// column长度已经满了，不需要再继续构造模板，直接跳出
break;
} else if (OB_FAIL(resolve_paramed_const(ctx))) {
LOG_WARN("failed to resolve paramed const", K(ret));
} else {
// do nothing
}
}
// pop stack
stack_frames.pop_back();
--frame_idx;
LOG_DEBUG("after popping frame", K(stack_frames), K(frame_idx));
} else {
// do nothing
}
if (OB_FAIL(ret) || frame_idx < 0) {
// do nothing
} else if (stack_frames.at(frame_idx).cur_node_->num_child_ > 0) {
if (OB_ISNULL(stack_frames.at(frame_idx).cur_node_->children_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid null children", K(ret), K(stack_frames.at(frame_idx).cur_node_->children_), K(frame_idx));
} else {
TraverseStackFrame frame = stack_frames.at(frame_idx);
for (int64_t i = frame.next_child_idx_; OB_SUCC(ret) && i < frame.cur_node_->num_child_; i++) {
if (OB_ISNULL(frame.cur_node_->children_[i])) {
stack_frames.at(frame_idx).next_child_idx_ = i + 1;
} else if (OB_FAIL(stack_frames.push_back(TraverseStackFrame{frame.cur_node_->children_[i], 0}))) {
LOG_WARN("failed to push back eleemnt", K(ret));
} else {
stack_frames.at(frame_idx).next_child_idx_ = i + 1;
LOG_DEBUG("after pushing frame", K(stack_frames));
break;
}
} // for end
}
}
} // for end
if (OB_SUCC(ret)) {
// 如果常量之后还有字符串
int64_t res_start_pos = expr_pos - tree->raw_sql_offset_;
int64_t tmp_len = std::min(org_field_name.length() - res_start_pos, buf_len - param_info.name_len_);
if (tmp_len > 0) {
int32_t len = static_cast<int32_t>(tmp_len);
MEMCPY(param_info.paramed_field_name_ + param_info.name_len_, org_field_name.ptr() + res_start_pos, len);
param_info.name_len_ += len;
}
if (T_QUESTIONMARK == tree->children_[0]->type_
&& 1 == tree->children_[0]->is_column_varchar_) {
param_info.esc_str_flag_ = true;
}
}
}
if (OB_FAIL(ret) || 0 == param_info.params_idx_.count()) {
// do nothing
} else if (OB_FAIL(select_item_param_infos->push_back(param_info))) {
SQL_PC_LOG(WARN, "failed to push back element", K(ret));
} else {
tree->value_ = select_item_param_infos->count() - 1;
tree->is_val_paramed_item_idx_ = 1;
LOG_DEBUG("add a paramed info", K(param_info));
}
return ret;
}
int ObSqlParameterization::resolve_paramed_const(SelectItemTraverseCtx &ctx)
{
int ret = OB_SUCCESS;
int64_t idx = ctx.tree_->raw_param_idx_;
if (idx >= ctx.raw_params_.count()) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid argument", K(ret), K(idx), K(ctx.raw_params_.count()));
} else if (OB_ISNULL(ctx.raw_params_.at(idx)) || OB_ISNULL(ctx.raw_params_.at(idx)->node_)) {
ret = OB_INVALID_ARGUMENT;
SQL_PC_LOG(WARN, "invalid arguemnt", K(ret));
} else {
const ParseNode *param_node = ctx.raw_params_.at(idx)->node_;
int64_t tmp_len = std::min(ctx.buf_len_ - ctx.param_info_.name_len_, param_node->raw_sql_offset_ - ctx.expr_pos_);
// In the case of select _binary 'abc';, special processing is required, because the value of
// org_expr_name_ is the same as that of raw param in this scenario.
// So it is judged here that if org_expr_name_ is the same as param_node->str_value_ value
// there is no need to copy it. paramed_field_name_ should be replaced with '?'
if (0 == ctx.org_expr_name_.case_compare(ObString(param_node->str_len_, param_node->str_value_))) {
// do nothing
} else if (tmp_len > 0 && ctx.org_expr_name_.length() > 0) {
int32_t len = static_cast<int64_t>(tmp_len);
MEMCPY(ctx.param_info_.paramed_field_name_ + ctx.param_info_.name_len_, ctx.org_expr_name_.ptr() + ctx.expr_pos_ - ctx.expr_start_pos_, len);
ctx.param_info_.name_len_ += len;
}
ctx.expr_pos_ = param_node->raw_sql_offset_ + param_node->text_len_;
if (OB_FAIL(ctx.param_info_.questions_pos_.push_back(ctx.param_info_.name_len_))) {
SQL_PC_LOG(WARN, "failed to push back element", K(ret));
} else if (OB_FAIL(ctx.param_info_.params_idx_.push_back(idx))) {
SQL_PC_LOG(WARN, "failed to push back element", K(ret));
} else {
if (ctx.param_info_.name_len_ < ctx.buf_len_) {
ctx.param_info_.paramed_field_name_[ctx.param_info_.name_len_++] = '?'; // 替换常量为'?'
}
if (ctx.tree_->is_neg_ && OB_FAIL(ctx.param_info_.neg_params_idx_.add_member(idx))) {
SQL_PC_LOG(WARN, "failed to add member", K(ret), K(idx));
}
if (OB_SUCC(ret)) {
LOG_DEBUG("resolve a paramed const",
K(ctx.expr_pos_), K(ctx.expr_start_pos_), K(ctx.org_expr_name_),
K(param_node->raw_sql_offset_));
}
}
}
return ret;
}
int ObSqlParameterization::transform_minus_op(ObIAllocator &alloc, ParseNode *tree, bool is_from_pl)
{
int ret = OB_SUCCESS;
if (T_OP_MINUS != tree->type_) {
// do nothing
} else if (2 != tree->num_child_
|| OB_ISNULL(tree->children_)
|| OB_ISNULL(tree->children_[1])) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid minus tree", K(ret));
} else if (1 == tree->children_[1]->is_assigned_from_child_) {
// select 1 - (2) from dual;
// select 1 - (2/3/4) from dual;
// 对于常量节点2，都不能转换成-2
// do nothing
} else if (ob_is_numeric_type(ITEM_TO_OBJ_TYPE(tree->children_[1]->type_)) &&
tree->children_[1]->value_ >= 0) {
ParseNode *child = tree->children_[1];
tree->type_ = T_OP_ADD;
if (!is_from_pl) {
if (T_INT == child->type_) {
child->value_ = -child->value_;
}
char *new_str = static_cast<char *>(parse_malloc(child->str_len_ + 2, &alloc));
char *new_raw_text = static_cast<char *>(parse_malloc(child->text_len_ + 2, &alloc));
if (OB_ISNULL(new_str) || OB_ISNULL(new_raw_text)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate memory", K(ret), K(new_raw_text), K(new_str));
} else {
new_str[0] = '-';
new_raw_text[0] = '-';
MEMMOVE(new_str + 1, child->str_value_, child->str_len_);
MEMMOVE(new_raw_text + 1, child->raw_text_, child->text_len_);
new_str[child->str_len_ + 1] = '\0';
new_raw_text[child->text_len_ + 1] = '\0';
child->str_len_++;
child->text_len_ ++;
child->str_value_ = new_str;
child->raw_text_ = new_raw_text;
child->is_trans_from_minus_ = 1;
}
} else {
child->is_trans_from_minus_ = 1;
}
} else if (T_OP_MUL == tree->children_[1]->type_
|| T_OP_DIV == tree->children_[1]->type_
|| T_OP_INT_DIV == tree->children_[1]->type_
|| (lib::is_mysql_mode() && T_OP_MOD == tree->children_[1]->type_)) {
/* '0 - 2 * 3' should be transformed to '0 + (-2) * 3' */
/* '0 - 2 / 3' should be transformed to '0 + (-2) / 3' */
/* '0 - 4 mod 3' should be transformed to '0 + (-4 mod 3)' */
/* '0 - 2/3/4' => '0 + (-2/3/4)' */
/* notify that, syntax tree of '0 - 2/3/4' is */
/* - */
/* / \ */
/* 0 div */
/* / \ */
/* div 4 */
/* / \ */
/* 2 3 */
/* so, we need to find the leftest leave node and change its value and str */
/* same for '%','*', mod */
/* */
/* 在oracle模式下只有mod函数，比如select 1 - mod(mod(3, 4), 2) from dual; */
/* 语法树为： */
/* - */
/* / \ */
/* 1 mod */
/* / \ */
/* mod 2 */
/* / \ */
/* 3 4 */
/* 这个语法树和mysql模式下的select 1 - 3%4%2 from dual是一样的，但是-和3在oracle模式下不能结合在一起 */
/* 否则快速参数化和硬解析得到的常量不一样（3和-3)，所以oracle模式下T_OP_MOD不能转换减号 */
ParseNode *const_node = NULL;
ParseNode *op_node = tree->children_[1];
if (OB_FAIL(find_leftest_const_node(*op_node, const_node))) {
LOG_WARN("failed to find leftest const node", K(ret));
} else if (OB_ISNULL(const_node)) {
// 1 - (2)/3, -和2也是不能结合的
// do nothing
} else {
tree->type_ = T_OP_ADD;
if (!is_from_pl) {
if (T_INT == const_node->type_) {
const_node->value_ = -const_node->value_;
}
char *new_str = static_cast<char *>(parse_malloc(const_node->str_len_ + 2, &alloc));
char *new_raw_text = static_cast<char *>(parse_malloc(const_node->text_len_ + 2, &alloc));
if (OB_ISNULL(new_str) || OB_ISNULL(new_raw_text)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to alloc memory", K(ret), K(new_str), K(new_raw_text));
} else {
new_str[0] = '-';
new_raw_text[0] = '-';
MEMMOVE(new_str + 1, const_node->str_value_, const_node->str_len_);
MEMMOVE(new_raw_text + 1, const_node->raw_text_, const_node->text_len_);
new_str[const_node->str_len_ + 1] = '\0';
new_raw_text[const_node->text_len_]= '\0';
const_node->str_len_++;
const_node->text_len_++;
const_node->str_value_ = new_str;
const_node->raw_text_ = new_raw_text;
const_node->is_trans_from_minus_ = 1;
}
} else {
const_node->is_trans_from_minus_ = 1;
}
}
} else {
// do nothing
}
return ret;
}
int ObSqlParameterization::find_leftest_const_node(ParseNode &cur_node, ParseNode *&const_node)
{
int ret = OB_SUCCESS;
if (ob_is_numeric_type(ITEM_TO_OBJ_TYPE(cur_node.type_))
&& 0 == cur_node.is_assigned_from_child_) {
const_node = &cur_node;
} else if (1 == cur_node.is_assigned_from_child_) {
// do nothing
} else if (T_OP_MUL == cur_node.type_ || T_OP_DIV == cur_node.type_
|| T_OP_INT_DIV == cur_node.type_ || T_OP_MOD == cur_node.type_) {
/* 对于1 - (2-3)/4，语法树为 */
/* - */
/* / \ */
/* 1 div */
/* / \ */
/* - 4 */
/* / \ */
/* 2 3 */
/* 这时候-是不能和2结合的，也就是不能转换语树 */
/* 对于一元操作符（一元操作符优先级大于减操作),比如负号 */
/* 1 - (-2)/4 */
/* 语法树为： */
/* - */
/* / \ */
/* 1 div */
/* / \ */
/* neg 4 */
/* | */
/* 2 */
/* 这种情况下，-也不能2结合 */
/* 所以只有T_OP_MUL、T_OP_DIV和T_OP_MOD走到这条路径上 */
if (OB_ISNULL(cur_node.children_) || 2 != cur_node.num_child_
|| OB_ISNULL(cur_node.children_[0]) || OB_ISNULL(cur_node.children_[1])) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument");
} else if (OB_FAIL(find_leftest_const_node(*cur_node.children_[0], const_node))) {
LOG_WARN("failed to find leftest const node", K(ret));
} else {
// do nothing
}
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink