File parse_tree.h¶
File List > cubrid > src > parser > parse_tree.h
Go to the documentation of this file
/*
* Copyright 2008 Search Solution Corporation
* Copyright 2016 CUBRID Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/*
* parse_tree.h - Parse tree structures and types
*/
#ifndef _PARSE_TREE_H_
#define _PARSE_TREE_H_
#if defined (SERVER_MODE)
#error Does not belong to server module
#endif /* SERVER_MODE */
#ident "$Id$"
#include <setjmp.h>
#include <assert.h>
#include "class_object.h"
#include "compile_context.h"
#include "config.h"
#include "cursor.h"
#include "db_function.hpp"
#include "json_table_def.h"
#include "message_catalog.h"
#include "string_opfunc.h"
#include "system_parameter.h"
#include "hide_password.h"
#include "misctype_def.h"
// forward definitions
struct json_t;
#define MAX_PRINT_ERROR_CONTEXT_LENGTH 64
//this could be a variadic template function; directly use pt_frob_error() for formatted messages without catalog
#define pt_cat_error(parser, node, setNo, msgNo, ...) \
pt_frob_error(parser, node, msgcat_message(MSGCAT_CATALOG_CUBRID, setNo, msgNo), ##__VA_ARGS__)
#if 1 //not necessary anymore thanks to new pt_cat_error() and existing pt_frob_error()
#define PT_ERROR(parser, node, msg) pt_frob_error(parser, node, msg)
#define PT_ERRORc(parser, node, msg) pt_frob_error( parser, node, "%s", msg)
#define PT_ERRORf(parser, node, msg, arg1) pt_frob_error(parser, node, msg, arg1)
#define PT_ERRORf2(parser, node, msg, arg1, arg2) pt_frob_error(parser, node, msg, arg1, arg2)
#define PT_ERRORf3(parser, node, msg, arg1, arg2, arg3) pt_frob_error(parser, node, msg, arg1, arg2, arg3)
#define PT_ERRORf4(parser, node, msg, arg1, arg2, arg3, arg4) pt_frob_error(parser, node, msg, arg1, arg2, arg3, arg4)
#define PT_ERRORf5(parser, node, msg, arg1, arg2, arg3, arg4, arg5) pt_frob_error(parser, node, msg, arg1, arg2, arg3, arg4, arg5)
#define PT_ERRORm(parser, node, setNo, msgNo) pt_cat_error(parser, node, setNo, msgNo)
#define PT_ERRORmf(parser, node, setNo, msgNo, arg1) pt_cat_error(parser, node, setNo, msgNo, arg1)
#define PT_ERRORmf2(parser, node, setNo, msgNo, arg1, arg2) pt_cat_error(parser, node, setNo, msgNo, arg1, arg2)
#define PT_ERRORmf3(parser, node, setNo, msgNo, arg1, arg2, arg3) pt_cat_error(parser, node, setNo, msgNo, arg1, arg2, arg3)
#define PT_ERRORmf4(parser, node, setNo, msgNo, arg1, arg2, arg3, arg4) pt_cat_error(parser, node, setNo, msgNo, arg1, arg2, arg3, arg4)
#define PT_ERRORmf5(parser, node, setNo, msgNo, arg1, arg2, arg3, arg4 , arg5) pt_cat_error(parser, node, setNo, msgNo, arg1, arg2, arg3, arg4, arg5)
#endif
//this could be a variadic template function; directly use pt_frob_warning() for formatted messages without catalog
#define pt_cat_warning(parser, node, setNo, msgNo, ...) \
pt_frob_warning(parser, node, msgcat_message(MSGCAT_CATALOG_CUBRID, setNo, msgNo), ##__VA_ARGS__)
#if 1 //not necessary anymore thanks to pt_cat_warning() and existing pt_frob_warning()
#define PT_WARNING( parser, node, msg ) pt_frob_warning(parser, node, msg)
#define PT_WARNINGm(parser, node, setNo, msgNo) pt_cat_warning(parser, node, setNo, msgNo)
#define PT_WARNINGc( parser, node, msg ) pt_frob_warning(parser, node, msg)
#define PT_WARNINGf( parser, node, msg, arg1) pt_cat_warning(parser, node, msg, arg1)
#define PT_WARNINGf2( parser, node, msg, arg1, arg2) pt_cat_warning(parser, node, msg, arg1, arg2)
#define PT_WARNINGf3( parser, node, msg, arg1, arg2, arg3) pt_cat_warning(parser, node, msg, arg1, arg2, arg3)
#define PT_WARNINGmf(parser, node, setNo, msgNo, arg1) pt_cat_warning(parser, node, setNo, msgNo, arg1)
#define PT_WARNINGmf2(parser, node, setNo, msgNo, arg1, arg2) pt_cat_warning(parser, node, setNo, msgNo, arg1, arg2)
#define PT_WARNINGmf3(parser, node, setNo, msgNo, arg1, arg2, arg3) pt_cat_warning(parser, node, setNo, msgNo, arg1, arg2, arg3)
#endif
#define PT_SET_JMP_ENV(parser) \
do { \
if (setjmp((parser)->jmp_env) != 0) { \
pt_record_error((parser), (parser)->statement_number, \
(parser)->line, \
(parser)->column, \
msgcat_message (MSGCAT_CATALOG_CUBRID, \
MSGCAT_SET_PARSER_SEMANTIC, \
MSGCAT_SEMANTIC_OUT_OF_MEMORY), \
NULL); \
(parser)->jmp_env_active = 0; \
if ((parser)->au_save) \
AU_ENABLE((parser)->au_save); \
return NULL; \
} \
else (parser)->jmp_env_active = 1; \
} while(0)
#define PT_CLEAR_JMP_ENV(parser) \
do { \
(parser)->jmp_env_active = 0; \
} while(0)
#define PT_INTERNAL_ERROR(parser, what) \
pt_internal_error((parser), __FILE__, __LINE__, (what))
// macros for PARSER_CONTEXT
#define PT_IS_FOR_PL_COMPILE(parser) \
((parser)->flag.is_parsing_static_sql == 1)
// macros for PT_NODE */
#define PT_IS_QUERY_NODE_TYPE(x) \
( (x) == PT_SELECT || (x) == PT_UNION \
|| (x) == PT_DIFFERENCE || (x) == PT_INTERSECTION)
#define PT_IS_CLASSOID_NAME(x) \
( (x)->info.name.meta_class == PT_CLASSOID_ATTR)
#define PT_IS_NULL_NODE(e) ((e)->type_enum==PT_TYPE_NA \
|| (e)->type_enum==PT_TYPE_NULL)
#define PT_IS_NUMERIC_TYPE(t) \
( ((t) == PT_TYPE_INTEGER) || \
((t) == PT_TYPE_BIGINT) || \
((t) == PT_TYPE_FLOAT) || \
((t) == PT_TYPE_DOUBLE) || \
((t) == PT_TYPE_SMALLINT) || \
((t) == PT_TYPE_MONETARY) || \
((t) == PT_TYPE_LOGICAL) || \
((t) == PT_TYPE_NUMERIC))
#define PT_IS_DISCRETE_NUMBER_TYPE(t) \
( ((t) == PT_TYPE_INTEGER) || \
((t) == PT_TYPE_BIGINT) || \
((t) == PT_TYPE_SMALLINT))
#define PT_IS_COUNTER_TYPE(t) \
PT_IS_DISCRETE_NUMBER_TYPE(t)
#define PT_IS_COLLECTION_TYPE(t) \
( ((t) == PT_TYPE_SET) || \
((t) == PT_TYPE_MULTISET) || \
((t) == PT_TYPE_SEQUENCE))
#define PT_IS_STRING_TYPE(t) \
( ((t) == PT_TYPE_CHAR) || \
((t) == PT_TYPE_VARCHAR) || \
((t) == PT_TYPE_BIT) || \
((t) == PT_TYPE_VARBIT))
#define PT_IS_SIMPLE_CHAR_STRING_TYPE(t) \
( ((t) == PT_TYPE_CHAR) || \
((t) == PT_TYPE_VARCHAR))
#define PT_IS_CHAR_STRING_TYPE(t) \
( ((t) == PT_TYPE_CHAR) || \
((t) == PT_TYPE_VARCHAR))
#define PT_IS_BIT_STRING_TYPE(t) \
( ((t) == PT_TYPE_BIT) || \
((t) == PT_TYPE_VARBIT))
#define PT_IS_COMPLEX_TYPE(t) \
( ((t) == PT_TYPE_MONETARY) || \
((t) == PT_TYPE_NUMERIC) || \
((t) == PT_TYPE_CHAR) || \
((t) == PT_TYPE_VARCHAR) || \
((t) == PT_TYPE_BIT) || \
((t) == PT_TYPE_VARBIT) || \
((t) == PT_TYPE_OBJECT) || \
((t) == PT_TYPE_SET) || \
((t) == PT_TYPE_MULTISET) || \
((t) == PT_TYPE_SEQUENCE) || \
((t) == PT_TYPE_ENUMERATION))
#define PT_IS_DATE_TIME_WITH_TZ_TYPE(t) \
( (t) == PT_TYPE_TIMESTAMPTZ || \
(t) == PT_TYPE_TIMESTAMPLTZ || \
(t) == PT_TYPE_DATETIMETZ || \
(t) == PT_TYPE_DATETIMELTZ)
#define PT_IS_DATE_TIME_TYPE(t) \
( ((t) == PT_TYPE_DATE) || \
((t) == PT_TYPE_TIME) || \
((t) == PT_TYPE_TIMESTAMP) || \
((t) == PT_TYPE_DATETIME) || \
((t) == PT_TYPE_DATETIMETZ) || \
((t) == PT_TYPE_DATETIMELTZ) || \
((t) == PT_TYPE_TIMESTAMPTZ) || \
((t) == PT_TYPE_TIMESTAMPLTZ))
#define PT_HAS_DATE_PART(t) \
( ((t) == PT_TYPE_DATE) || \
((t) == PT_TYPE_TIMESTAMP) || \
((t) == PT_TYPE_DATETIME) || \
((t) == PT_TYPE_DATETIMETZ) || \
((t) == PT_TYPE_DATETIMELTZ) || \
((t) == PT_TYPE_TIMESTAMPTZ) || \
((t) == PT_TYPE_TIMESTAMPLTZ))
#define PT_HAS_TIME_PART(t) \
( ((t) == PT_TYPE_TIME) || \
((t) == PT_TYPE_TIMESTAMP) || \
((t) == PT_TYPE_TIMESTAMPTZ) || \
((t) == PT_TYPE_TIMESTAMPLTZ) || \
((t) == PT_TYPE_DATETIME) || \
((t) == PT_TYPE_DATETIMETZ) || \
((t) == PT_TYPE_DATETIMELTZ))
#define PT_IS_LTZ_TYPE(t) \
((t) == PT_TYPE_TIMESTAMPLTZ || (t) == PT_TYPE_DATETIMELTZ)
#define PT_IS_PRIMITIVE_TYPE(t) \
( ((t) != PT_TYPE_OBJECT) && ((t) != PT_TYPE_NONE))
#define PT_IS_PARAMETERIZED_TYPE(t) \
( ((t) == PT_TYPE_NUMERIC) || \
((t) == PT_TYPE_VARCHAR) || \
((t) == PT_TYPE_CHAR) || \
((t) == PT_TYPE_VARBIT) || \
((t) == PT_TYPE_BIT) || \
((t) == PT_TYPE_ENUMERATION))
#define PT_IS_LOB_TYPE(t) \
( ((t) == PT_TYPE_BLOB) || \
((t) == PT_TYPE_CLOB))
#define PT_HAS_COLLATION(t) \
( ((t) == PT_TYPE_CHAR) || \
((t) == PT_TYPE_VARCHAR) || \
((t) == PT_TYPE_ENUMERATION))
#define PT_VALUE_GET_BYTES(node) \
((node) == NULL ? NULL : \
(node)->info.value.data_value.str->bytes)
#define pt_is_select(n) PT_IS_SELECT(n)
#define pt_is_union(n) PT_IS_UNION(n)
#define pt_is_intersection(n) PT_IS_INTERSECTION(n)
#define pt_is_difference(n) PT_IS_DIFFERENCE(n)
#define pt_is_query(n) PT_IS_QUERY(n)
#define pt_is_correlated_subquery(n) PT_IS_CORRELATED_SUBQUERY(n)
#define pt_is_dot_node(n) PT_IS_DOT_NODE(n)
#define pt_is_expr_node(n) PT_IS_EXPR_NODE(n)
#define pt_is_function(n) PT_IS_FUNCTION(n)
#define pt_is_sp(n) PT_IS_SP(n)
#define pt_is_multi_col_term(n) PT_IS_MULTI_COL_TERM(n)
#define pt_is_name_node(n) PT_IS_NAME_NODE(n)
#define pt_is_oid_name(n) PT_IS_OID_NAME(n)
#define pt_is_value_node(n) PT_IS_VALUE_NODE(n)
#define pt_is_set_type(n) PT_IS_SET_TYPE(n)
#define pt_is_hostvar(n) PT_IS_HOSTVAR(n)
#define pt_is_input_hostvar(n) PT_IS_INPUT_HOSTVAR(n)
#define pt_is_output_hostvar(n) PT_IS_OUTPUT_HOSTVAR(n)
#define pt_is_const(n) PT_IS_CONST(n)
#define pt_is_parameter(n) PT_IS_PARAMETER(n)
#define pt_is_input_parameter(n) PT_IS_INPUT_PARAMETER(n)
#define pt_is_const_not_hostvar(n) PT_IS_CONST_NOT_HOSTVAR(n)
#define pt_is_const_input_hostvar(n) PT_IS_CONST_INPUT_HOSTVAR(n)
#define pt_is_cast_const_input_hostvar(n) PT_IS_CAST_CONST_INPUT_HOSTVAR(n)
#define pt_is_instnum(n) PT_IS_INSTNUM(n)
#define pt_is_orderbynum(n) PT_IS_ORDERBYNUM(n)
#define pt_is_distinct(n) PT_IS_DISTINCT(n)
#define pt_is_meta(n) PT_IS_META(n)
#define pt_is_update_object(n) PT_IS_UPDATE_OBJECT(n)
#define pt_is_unary(op) PT_IS_UNARY(op)
#define PT_IS_SELECT(n) \
( (n) && ((n)->node_type == PT_SELECT) )
#define PT_IS_UNION(n) \
( (n) && ((n)->node_type == PT_UNION) )
#define PT_IS_INTERSECTION(n) \
( (n) && ((n)->node_type == PT_INTERSECTION) )
#define PT_IS_DIFFERENCE(n) \
( (n) && ((n)->node_type == PT_DIFFERENCE) )
#define PT_IS_QUERY(n) \
( (n) && (PT_IS_QUERY_NODE_TYPE((n)->node_type)) )
#define PT_IS_CORRELATED_SUBQUERY(n) \
( PT_IS_QUERY((n)) && ((n)->info.query.correlation_level > 0) )
#define PT_IS_DOT_NODE(n) \
( (n) && ((n)->node_type == PT_DOT_) )
#define PT_IS_EXPR_NODE(n) \
( (n) && ((n)->node_type == PT_EXPR) )
#define PT_IS_ASSIGN_NODE(n) \
( (n) && ((n)->node_type == PT_EXPR && (n)->info.expr.op == PT_ASSIGN) )
#define PT_IS_FUNCTION(n) \
( (n) && ((n)->node_type == PT_FUNCTION) )
#define PT_IS_MULTI_COL_TERM(n) \
( (n) && \
PT_IS_FUNCTION((n)) && \
PT_IS_SET_TYPE ((n)) && \
(n)->info.function.function_type == F_SEQUENCE)
#define PT_IS_NAME_NODE(n) \
( (n) && ((n)->node_type == PT_NAME) )
#define PT_IS_OID_NAME(n) \
( (n) && \
((n)->node_type == PT_NAME && \
((n)->info.name.meta_class == PT_OID_ATTR || \
(n)->info.name.meta_class == PT_VID_ATTR) ) \
)
#define PT_IS_VALUE_NODE(n) \
( (n) && ((n)->node_type == PT_VALUE) )
#define PT_IS_INSERT_VALUE_NODE(n) \
( (n) && ((n)->node_type == PT_INSERT_VALUE) )
#define PT_IS_SET_TYPE(n) \
( (n) && ((n)->type_enum == PT_TYPE_SET || \
(n)->type_enum == PT_TYPE_MULTISET || \
(n)->type_enum == PT_TYPE_SEQUENCE) \
)
#define PT_IS_HOSTVAR(n) \
( (n) && ((n)->node_type == PT_HOST_VAR) )
#define PT_IS_INPUT_HOSTVAR(n) \
( (n) && ((n)->node_type == PT_HOST_VAR && \
(n)->info.host_var.var_type == PT_HOST_IN) \
)
#define PT_IS_OUTPUT_HOSTVAR(n) \
( (n) && ((n)->node_type == PT_HOST_VAR && \
(n)->info.host_var.var_type == PT_HOST_OUT) \
)
#define PT_IS_PARAMETER(n) \
( (n) && ((n)->node_type == PT_NAME && \
(n)->info.name.meta_class == PT_PARAMETER) )
#define PT_IS_INPUT_PARAMETER(n) \
( (n) && ((n)->node_type == PT_NAME && \
(n)->info.name.meta_class == PT_PARAMETER && \
(n)->info.name.resolved == NULL) )
#define PT_IS_CONST(n) \
( (n) && ((n)->node_type == PT_VALUE || \
(n)->node_type == PT_HOST_VAR || \
((n)->node_type == PT_NAME && (n)->info.name.meta_class == PT_PARAMETER) ) \
)
#define PT_IS_CONST_NOT_HOSTVAR(n) \
( (n) && ((n)->node_type == PT_VALUE || \
((n)->node_type == PT_NAME && (n)->info.name.meta_class == PT_PARAMETER) ) \
)
#define PT_IS_CONST_INPUT_HOSTVAR(n) \
( (n) && ((n)->node_type == PT_VALUE || \
((n)->node_type == PT_NAME && (n)->info.name.meta_class == PT_PARAMETER) || \
((n)->node_type == PT_HOST_VAR && (n)->info.host_var.var_type == PT_HOST_IN)) \
)
#define PT_IS_CAST_CONST_INPUT_HOSTVAR(n) \
( (n) && \
(n)->node_type == PT_EXPR && \
(n)->info.expr.op == PT_CAST && \
PT_IS_CONST_INPUT_HOSTVAR((n)->info.expr.arg1) )
#define PT_IS_INSTNUM(n) \
( (n) && ((n)->node_type == PT_EXPR && \
((n)->info.expr.op == PT_INST_NUM || (n)->info.expr.op == PT_ROWNUM)) \
)
#define PT_IS_ORDERBYNUM(n) \
( (n) && ((n)->node_type == PT_EXPR && ((n)->info.expr.op == PT_ORDERBY_NUM)) )
#define PT_IS_GROUPBYNUM(n) \
( (n) && ((n)->node_type == PT_FUNCTION && ((n)->info.function.function_type == PT_GROUPBY_NUM)) )
#define PT_IS_DISTINCT(n) \
( (n) && PT_IS_QUERY_NODE_TYPE((n)->node_type) && (n)->info.query.all_distinct != PT_ALL )
#define PT_IS_META(n) \
( ((n) ? ((n)->node_type == PT_NAME ? \
((n)->info.name.meta_class == PT_META_CLASS || \
(n)->info.name.meta_class == PT_META_ATTR || \
(n)->info.name.meta_class == PT_CLASSOID_ATTR || \
(n)->info.name.meta_class == PT_OID_ATTR) : \
((n)->node_type == PT_SPEC && ((n)->info.spec.meta_class == PT_META_CLASS))) \
: false) )
#define PT_IS_HINT_NODE(n) \
( (n) && ((n)->node_type == PT_NAME && (n)->info.name.meta_class == PT_HINT_NAME) )
#define PT_IS_UPDATE_OBJECT(n) \
( (n) && (n)->node_type == PT_UPDATE && (n)->info.update.spec == NULL )
#define PT_IS_UNARY(op) \
( (op) == PT_NOT || \
(op) == PT_IS_NULL || \
(op) == PT_IS_NOT_NULL || \
(op) == PT_EXISTS || \
(op) == PT_PRIOR || \
(op) == PT_CONNECT_BY_ROOT || \
(op) == PT_QPRIOR || \
(op) == PT_UNARY_MINUS) )
#define PT_IS_N_COLUMN_UPDATE_EXPR(n) \
( (n) && \
(n)->node_type == PT_EXPR && \
(n)->info.expr.op == PT_PATH_EXPR_SET )
#define PT_DOES_FUNCTION_HAVE_DIFFERENT_ARGS(op) \
((op) == PT_MODULUS || (op) == PT_SUBSTRING || \
(op) == PT_LPAD || (op) == PT_RPAD || (op) == PT_ADD_MONTHS || \
(op) == PT_TO_CHAR || (op) == PT_TO_NUMBER || \
(op) == PT_POWER || (op) == PT_ROUND || \
(op) == PT_TRUNC || (op) == PT_INSTR || \
(op) == PT_LEAST || (op) == PT_GREATEST || \
(op) == PT_FIELD || \
(op) == PT_REPEAT || (op) == PT_SUBSTRING_INDEX || \
(op) == PT_MAKEDATE || (op) == PT_MAKETIME || (op) == PT_IF || \
(op) == PT_STR_TO_DATE)
#define PT_REQUIRES_HIERARCHICAL_QUERY(op) \
( (op) == PT_LEVEL || \
(op) == PT_CONNECT_BY_ISCYCLE || \
(op) == PT_CONNECT_BY_ISLEAF || \
(op) == PT_PRIOR || \
(op) == PT_CONNECT_BY_ROOT || \
(op) == PT_QPRIOR || \
(op) == PT_SYS_CONNECT_BY_PATH )
#define PT_CHECK_HQ_OP_EXCEPT_PRIOR(op) \
( (op) == PT_LEVEL || \
(op) == PT_CONNECT_BY_ISCYCLE || \
(op) == PT_CONNECT_BY_ISLEAF || \
(op) == PT_CONNECT_BY_ROOT || \
(op) == PT_SYS_CONNECT_BY_PATH )
#define PT_IS_NUMBERING_AFTER_EXECUTION(op) \
( (op) == PT_INST_NUM || \
(op) == PT_ROWNUM || \
/*(int)(op) == (int)PT_GROUPBY_NUM || - TODO: this does not belong here. */ \
(op) == PT_ORDERBY_NUM )
#define PT_IS_SERIAL(op) \
( (op) == PT_CURRENT_VALUE || (op) == PT_NEXT_VALUE )
#define PT_IS_EXPR_NODE_WITH_OPERATOR(n, op_type) \
( (PT_IS_EXPR_NODE (n)) && ((n)->info.expr.op == (op_type)) )
#define PT_IS_EXPR_NODE_WITH_COMP_OP(n) \
( (PT_IS_EXPR_NODE (n)) && \
((n)->info.expr.op == PT_EQ || \
(n)->info.expr.op == PT_GE || \
(n)->info.expr.op == PT_GT || \
(n)->info.expr.op == PT_LT || \
(n)->info.expr.op == PT_LE || \
(n)->info.expr.op == PT_GT_INF || \
(n)->info.expr.op == PT_LT_INF || \
(n)->info.expr.op == PT_RANGE || \
(n)->info.expr.op == PT_BETWEEN))
#define PT_IS_EXPR_NODE_WITH_NON_PUSHABLE(n) \
( (PT_IS_EXPR_NODE (n)) && \
((n)->info.expr.op == PT_DRANDOM || \
(n)->info.expr.op == PT_DRAND || \
(n)->info.expr.op == PT_RANDOM || \
(n)->info.expr.op == PT_RAND || \
(n)->info.expr.op == PT_SYS_GUID ))
#define PT_IS_EXPR_WITH_PRIOR_ARG(x) (PT_IS_EXPR_NODE (x) && \
PT_IS_EXPR_NODE_WITH_OPERATOR ((x)->info.expr.arg1, PT_PRIOR))
#define PT_NODE_DATA_TYPE(n) \
( (n) ? (n)->data_type : NULL )
#define PT_IS_SORT_SPEC_NODE(n) \
( (n) && ((n)->node_type == PT_SORT_SPEC) )
#define PT_IS_VALUE_QUERY(n) \
((n)->flag.is_value_query == 1)
#define PT_SET_VALUE_QUERY(n) \
((n)->flag.is_value_query = 1)
#define PT_IS_ORDER_DEPENDENT(n) \
( (n) ? \
(PT_IS_EXPR_NODE (n) ? (n)->info.expr.is_order_dependent \
: (PT_IS_FUNCTION(n) ? (n)->info.function.is_order_dependent \
: (PT_IS_QUERY(n) ? (n)->info.query.is_order_dependent : false))) \
: false)
#define PT_IS_ANALYTIC_NODE(n) \
( (n) && (n)->node_type == PT_FUNCTION && \
(n)->info.function.analytic.is_analytic )
#define PT_IS_POINTER_REF_NODE(n) \
( (n) && (n)->node_type == PT_NODE_POINTER && \
(n)->info.pointer.type == PT_POINTER_REF )
#define PT_IS_VACUUM_NODE(n) \
( (n) && (n)->node_type == PT_VACUUM )
#define PT_SET_ORDER_DEPENDENT_FLAG(n, f) \
do { \
if ((n)) \
{ \
if (PT_IS_EXPR_NODE (n)) \
(n)->info.expr.is_order_dependent = (f); \
else if (PT_IS_FUNCTION (n)) \
(n)->info.function.is_order_dependent = (f); \
else if (PT_IS_QUERY (n)) \
(n)->info.query.is_order_dependent = (f); \
} \
} while (0)
#define PT_IS_DBLINK_DML_QUERY(n) \
((n->node_type == PT_INSERT && n->info.insert.spec->info.spec.remote_server_name) \
|| (n->node_type == PT_DELETE && n->info.delete_.spec->info.spec.remote_server_name) \
|| (n->node_type == PT_UPDATE && n->info.update.spec->info.spec.remote_server_name) \
|| (n->node_type == PT_MERGE && n->info.merge.into->info.spec.remote_server_name))
#define PT_CHECK_USER_SCHEMA_PROCEDURE_OR_FUNCTION(n) \
((n->info.dot.arg1->node_type == PT_NAME) \
&& (n->info.dot.arg2->node_type == PT_FUNCTION) \
&& (n->info.dot.arg2->info.function.function_type == PT_GENERIC) \
&& (strchr (n->info.dot.arg2->info.function.generic_name, '.') == NULL))
#if !defined (SERVER_MODE)
/* the following defines support host variable binding for internal statements.
internal statements can be generated on TEXT handling, and these statements
can include host variables derived from original statement. so, to look up
host variable table by internal statements at parser, keep the parser,
i.e parent_parser */
#define CLEAR_HOST_VARIABLES(parser_) \
do { DB_VALUE *hv; int i; \
for (i = 0, hv = parser_->host_variables; \
i < (parser_->host_var_count + parser_->auto_param_count); i++, hv++) \
db_value_clear(hv); \
free_and_init(parser_->host_variables); \
free_and_init(parser_->host_var_expected_domains);} while (0)
#define SET_HOST_VARIABLES_IF_INTERNAL_STATEMENT(parser_) \
do { if (parent_parser) { \
if (parser_->host_variables != NULL && \
parser_->host_variables != parent_parser->host_variables) { \
CLEAR_HOST_VARIABLES(parser_); } \
parser_->host_variables = parent_parser->host_variables; \
parser_->host_var_expected_domains = parent_parser->host_var_expected_domains; \
parser_->host_var_count = parent_parser->host_var_count; \
parser_->auto_param_count = parent_parser->auto_param_count; \
parser_->flag.set_host_var = 1; } } while (0)
#define RESET_HOST_VARIABLES_IF_INTERNAL_STATEMENT(parser_) \
do { if (parent_parser) { \
parser_->host_variables = NULL; parser_->host_var_count = 0; \
parser_->host_var_expected_domains = NULL; \
parser_->auto_param_count = 0; parser_->flag.set_host_var = 0; } } while (0)
#endif /* !SERVER_MODE */
/* NODE FUNCTION DECLARATIONS */
#define IS_UPDATE_OBJ(node) (node->node_type == PT_UPDATE && node->info.update.object_parameter)
#define PT_NODE_INIT_OUTERLINK(n) \
do { \
if ((n)) { \
(n)->next = NULL; \
(n)->or_next = NULL; \
(n)->etc = NULL; \
(n)->alias_print = NULL; \
} \
} while (0)
#define PT_NODE_COPY_NUMBER_OUTERLINK(t, s) \
do { \
if ((t) && (s)) { \
(t)->line_number = (s)->line_number; \
(t)->column_number = (s)->column_number; \
(t)->next = (s)->next; \
(t)->or_next = (s)->or_next; \
(t)->etc = (s)->etc; \
(t)->alias_print = (s)->alias_print; \
} \
} while (0)
#define PT_NODE_MOVE_NUMBER_OUTERLINK(t, s) \
do { \
PT_NODE_COPY_NUMBER_OUTERLINK((t), (s)); \
PT_NODE_INIT_OUTERLINK((s)); \
} while (0)
#define PT_NODE_PRINT_TO_ALIAS(p, n, c) \
do { \
unsigned int save_custom; \
\
if (!(p) || !(n) || (!(n)->info.query.flag.subquery_cached && n->alias_print)) \
break; \
save_custom = (p)->custom_print; \
(p)->custom_print |= (c); \
if (((p)->custom_print & PT_SHORT_PRINT) != 0) \
{ \
(n)->alias_print = pt_short_print ((p), (n)); \
} \
else \
{ \
(n)->alias_print = parser_print_tree ((p), (n)); \
} \
(p)->custom_print = save_custom; \
} while (0)
#define PT_NODE_PRINT_VALUE_TO_TEXT(p, n) \
do { \
if (!(p) || !(n) || (n)->node_type != PT_VALUE \
|| (n)->info.value.text) \
{ \
break; \
} \
(n)->info.value.text = parser_print_tree ((p), (n)); \
} while (0)
#define CAST_POINTER_TO_NODE(p) \
do { \
while ((p) && (p)->node_type == PT_NODE_POINTER && \
(p)->info.pointer.type == PT_POINTER_NORMAL) \
{ \
(p) = (p)->info.pointer.node; \
} \
} while (0)
#define PT_EMPTY INT_MAX
#define MAX_NUM_PLAN_TRACE 100
#define PT_GET_COLLATION_MODIFIER(p) \
(((p)->node_type == PT_EXPR) ? ((p)->info.expr.coll_modifier - 1) : \
(((p)->node_type == PT_VALUE) ? ((p)->info.value.coll_modifier - 1) : \
(((p)->node_type == PT_NAME) ? ((p)->info.name.coll_modifier - 1) : \
(((p)->node_type == PT_FUNCTION) ? ((p)->info.function.coll_modifier - 1) :\
(((p)->node_type == PT_DOT_) ? ((p)->info.dot.coll_modifier - 1) : (-1))))))
#define PT_HAS_COLLATION_MODIFIER(p) (PT_GET_COLLATION_MODIFIER((p)) != -1)
#define PT_SET_NODE_COLL_MODIFIER(p, coll) \
do { \
assert ((p) != NULL); \
if ((p)->node_type == PT_EXPR) \
{ \
(p)->info.expr.coll_modifier = (coll) + 1; \
} \
else if ((p)->node_type == PT_VALUE) \
{ \
(p)->info.value.coll_modifier = (coll) + 1; \
} \
else if ((p)->node_type == PT_NAME) \
{ \
(p)->info.name.coll_modifier = (coll) + 1; \
} \
else if ((p)->node_type == PT_FUNCTION) \
{ \
(p)->info.function.coll_modifier = (coll) + 1; \
} \
else \
{ \
assert ((p)->node_type == PT_DOT_); \
(p)->info.dot.coll_modifier = (coll) + 1; \
} \
} while (0)
/* Check if spec is flagged with any of flags_ */
#define PT_IS_SPEC_FLAG_SET(spec_, flags_) \
(((spec_)->info.spec.flag & (flags_)) != 0)
#define PT_SPEC_SPECIAL_INDEX_SCAN(spec_) \
(((spec_)->info.spec.flag & \
(PT_SPEC_FLAG_KEY_INFO_SCAN | PT_SPEC_FLAG_BTREE_NODE_INFO_SCAN)) != 0)
/* Obtain reserved name type from spec flag */
#define PT_SPEC_GET_RESERVED_NAME_TYPE(spec_) \
(((spec_) == NULL || (spec_)->node_type != PT_SPEC \
|| (spec_)->info.spec.flag == 0) ? \
/* is spec is NULL or not a PT_SPEC or flag is 0, return invalid */ \
RESERVED_NAME_INVALID : \
/* else */ \
((PT_IS_SPEC_FLAG_SET (spec_, PT_SPEC_FLAG_RECORD_INFO_SCAN)) ? \
/* if spec is flagged for record info */ \
RESERVED_NAME_RECORD_INFO : \
/* else */ \
((PT_IS_SPEC_FLAG_SET (spec_, PT_SPEC_FLAG_PAGE_INFO_SCAN)) ? \
/* if spec is flagged for page info */ \
RESERVED_NAME_PAGE_INFO : \
/* else */ \
((PT_IS_SPEC_FLAG_SET (spec_, PT_SPEC_FLAG_KEY_INFO_SCAN)) ? \
/* if spec is flagged for key info */ \
RESERVED_NAME_KEY_INFO : \
/* else */ \
((PT_IS_SPEC_FLAG_SET(spec_, PT_SPEC_FLAG_BTREE_NODE_INFO_SCAN) ? \
/* if spec is flagged for b-tree node info */ \
RESERVED_NAME_BTREE_NODE_INFO : \
/* spec is not flagged for any type of reserved names */ \
RESERVED_NAME_INVALID))))))
/* Check if according to spec flag should bind names as reserved */
#define PT_SHOULD_BIND_RESERVED_NAME(spec_) \
(PT_SPEC_GET_RESERVED_NAME_TYPE (spec_) != RESERVED_NAME_INVALID)
/* PT_SPEC node contains a derived table */
#define PT_SPEC_IS_DERIVED(spec_) \
((spec_)->info.spec.derived_table != NULL)
/* PT_SPEC node contains a CTE pointer */
#define PT_SPEC_IS_CTE(spec_) \
((spec_)->info.spec.cte_pointer != NULL)
/* PT_SPEC node contains an entity spec */
#define PT_SPEC_IS_ENTITY(spec_) \
((spec_)->info.spec.entity_name != NULL)
#define PT_IS_FALSE_WHERE_VALUE(node) \
(((node) != NULL && (node)->node_type == PT_VALUE \
&& ((node)->type_enum == PT_TYPE_NULL \
|| (PT_IS_SET_TYPE (node) \
&& ((node)->info.value.data_value.set == NULL)))) ? true : false)
#define PT_IS_SPEC_REAL_TABLE(spec_) PT_SPEC_IS_ENTITY(spec_)
#define PT_IS_METHOD(n) \
( (n) && (n)->node_type == PT_METHOD_CALL && \
( (n)->info.method_call.method_type == PT_IS_CLASS_MTHD || \
(n)->info.method_call.method_type == PT_IS_INST_MTHD) )
#define PT_IS_CLASS_METHOD(n) \
( (n) && (n)->node_type == PT_METHOD_CALL && \
(n)->info.method_call.method_type == PT_IS_CLASS_MTHD )
#define PT_IS_INSTANCE_METHOD(n) \
( (n) && (n)->node_type == PT_METHOD_CALL && \
(n)->info.method_call.method_type == PT_IS_INST_MTHD )
#define PT_IS_SP(n) \
( (n) && (n)->node_type == PT_METHOD_CALL && \
( (n)->info.method_call.method_type == PT_SP_PROCEDURE || \
(n)->info.method_call.method_type == PT_SP_FUNCTION) )
/* We would like to redefine the above macros below. And we will solve the below ones.
* - There is no need to repeat null checks for each macro.
*
* Be sure to do the following before using the macro below.
* - Check if PT_NODE is NULL.
* - Check the node_type for PT_NODE.
*/
#ifdef NDEBUG
#define PT_ASSERT_NOT_NULL(n) ((void) 0)
#define PT_ASSERT_NODE_TYPE(n, t) ((void) 0)
#else
#define PT_ASSERT_NOT_NULL(n) (assert ((n) != NULL))
#define PT_ASSERT_NODE_TYPE(n, t) (assert ((n) != NULL && (n)->node_type == (t)))
#endif
/* PT_NAME_INFO */
#define PT_NAME_ASSERT(n) (PT_ASSERT_NODE_TYPE ((n), PT_NAME))
#define PT_NAME_SPEC_ID(n) (PT_NAME_ASSERT ((n)), (n)->info.name.spec_id)
#define PT_NAME_ORIGINAL(n) (PT_NAME_ASSERT ((n)), (n)->info.name.original)
#define PT_NAME_RESOLVED(n) (PT_NAME_ASSERT ((n)), (n)->info.name.resolved)
#define PT_NAME_DB_OBJECT(n) (PT_NAME_ASSERT ((n)), (n)->info.name.db_object)
/* PT_CREATE_ENTITY */
#define PT_CREATE_ENTITY_ASSERT(n) (PT_ASSERT_NODE_TYPE ((n), PT_CREATE_ENTITY))
#define PT_CREATE_ENTITY_NAME(n) (PT_CREATE_ENTITY_ASSERT ((n)), (n)->info.create_entity.entity_name)
/* PT_EXPR */
#define PT_EXPR_ASSERT(n) (PT_ASSERT_NODE_TYPE ((n), PT_EXPR))
#define PT_EXPR_OP(n) (PT_EXPR_ASSERT ((n)), (n)->info.expr.op)
#define PT_EXPR_ARG1(n) (PT_EXPR_ASSERT ((n)), (n)->info.expr.arg1)
#define PT_EXPR_ARG2(n) (PT_EXPR_ASSERT ((n)), (n)->info.expr.arg2)
#define PT_EXPR_ARG3(n) (PT_EXPR_ASSERT ((n)), (n)->info.expr.arg3)
/* PT_RENAME */
#define PT_RENAME_ASSERT(n) (PT_ASSERT_NODE_TYPE ((n), PT_RENAME))
#define PT_RENAME_NEW_NAME(n) (PT_RENAME_ASSERT ((n)), (n)->info.rename.new_name)
/* PT_SPEC_INFO */
#define PT_SPEC_ASSERT(n) (PT_ASSERT_NODE_TYPE ((n), PT_SPEC))
#define PT_SPEC_ENTITY_NAME(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.entity_name)
#define PT_SPEC_CTE_POINTER(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.cte_pointer)
#define PT_SPEC_DERIVED_TABLE(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.derived_table)
#define PT_SPEC_FLAT_ENTITY_LIST(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.flat_entity_list)
#define PT_SPEC_ID(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.id)
#define PT_SPEC_JOIN_TYPE(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.join_type)
/* PT_SYNONYM_INFO */
#define PT_SYNONYM_NAME(n) ((n)->info.synonym.synonym_name)
#define PT_SYNONYM_OWNER_NAME(n) ((n)->info.synonym.synonym_owner_name)
#define PT_SYNONYM_OLD_NAME(n) ((n)->info.synonym.old_synonym_name)
#define PT_SYNONYM_OLD_OWNER_NAME(n) ((n)->info.synonym.old_synonym_owner_name)
#define PT_SYNONYM_NEW_NAME(n) ((n)->info.synonym.new_synonym_name)
#define PT_SYNONYM_NEW_OWNER_NAME(n) ((n)->info.synonym.new_synonym_owner_name)
#define PT_SYNONYM_TARGET_NAME(n) ((n)->info.synonym.target_name)
#define PT_SYNONYM_TARGET_OWNER_NAME(n) ((n)->info.synonym.target_owner_name)
#define PT_SYNONYM_COMMENT(n) ((n)->info.synonym.comment)
#define PT_SYNONYM_COMMENT_STR(n) ((n)->info.synonym.comment->info.value.data_value.str)
#define PT_SYNONYM_COMMENT_BYTES(n) ((n)->info.synonym.comment->info.value.data_value.str->bytes)
#define PT_SYNONYM_ACCESS_MODIFIER(n) ((n)->info.synonym.access_modifier)
#define PT_SYNONYM_OR_REPLACE(n) ((n)->info.synonym.or_replace)
#define PT_SYNONYM_IF_EXISTS(n) ((n)->info.synonym.if_exists)
#define PT_SYNONYM_IS_DBLINKED(n) ((n)->info.synonym.is_dblinked) /* for user.table@server */
/* PT_METHOD_CALL_INFO */
#define PT_METHOD_CALL_NAME(n) ((n)->info.method_call.method_name)
#define PT_METHOD_ARG_LIST(n) ((n)->info.method_call.arg_list)
#define PT_METHOD_CALL_AUTH_ID(n) ((n)->info.method_call.auth_id)
#define PT_METHOD_CALL_AUTH_NAME(n) ((n)->info.method_call.auth_name)
#define PT_METHOD_CALL_ON_CALL_TARGET(n) ((n)->info.method_call.on_call_target)
/* Check node_type of PT_NODE */
#define PT_NODE_IS_EXPR(n) (PT_ASSERT_NOT_NULL ((n)), (n)->node_type == PT_EXPR)
#define PT_NODE_IS_NAME(n) (PT_ASSERT_NOT_NULL ((n)), (n)->node_type == PT_NAME)
#define PT_NODE_IS_SPEC(n) (PT_ASSERT_NOT_NULL ((n)), (n)->node_type == PT_SPEC)
#define PT_NODE_IS_SYNONYM(n) (PT_ASSERT_NOT_NULL ((n)), \
(n)->node_type == PT_ALTER_SYNONYM || \
(n)->node_type == PT_CREATE_SYNONYM || \
(n)->node_type == PT_DROP_SYNONYM || \
(n)->node_type == PT_RENAME_SYNONYM)
/* Check node_type of PT_SPEC */
#define PT_SPEC_IS_ONLY(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.only_all == PT_ONLY)
#define PT_SPEC_IS_ALL(n) (PT_SPEC_ASSERT ((n)), (n)->info.spec.only_all == PT_ALL)
/* PT_SPEC_INFO */
#define PT_SPEC_GET_DB_OBJECT(n, r) \
do \
{ \
PT_NODE *entity_name = PT_SPEC_ENTITY_NAME ((n)); \
\
if (entity_name != NULL && PT_NODE_IS_NAME (entity_name)) \
{ \
if (PT_NAME_DB_OBJECT (entity_name) != NULL) \
{ \
(r) = PT_NAME_DB_OBJECT (entity_name); \
} \
else \
{ \
(r) = sm_find_class (PT_NAME_ORIGINAL (entity_name)); \
assert ((r) != NULL); \
} \
} \
else \
{ \
(r) = NULL; \
} \
} \
while (0)
/*
Enumerated types of parse tree statements
WARNING ------ WARNING ----- WARNING
Member functions parser_new_node, parser_init_node, parser_print_tree, which take a node as an argument
are accessed by function tables indexed by node_type. The functions in
the tables must appear in EXACTLY the same order as the node types
defined below. If you add a new node type you must create the
functions to manipulate it and put these in the tables. Else crash and burn.
*/
/* enumeration for parser_walk_tree() */
enum
{
PT_STOP_WALK = 0,
PT_CONTINUE_WALK,
PT_LEAF_WALK,
PT_LIST_WALK
};
enum
{
PT_USER_SELECT = 0,
PT_MERGE_SELECT
};
enum pt_custom_print
{
PT_SUPPRESS_RESOLVED = 0x1,
PT_SUPPRESS_META_ATTR_CLASS = (0x1 << 1),
PT_SUPPRESS_INTO = (0x1 << 2),
PT_SUPPRESS_SELECTOR = (0x1 << 3),
PT_SUPPRESS_SELECT_LIST = (0x1 << 4),
PT_SUPPRESS_QUOTES = (0x1 << 5),
PT_PRINT_ALIAS = (0x1 << 6),
PT_PAD_BYTE = (0x1 << 7),
PT_CONVERT_RANGE = (0x1 << 8),
PT_PRINT_DB_VALUE = (0x1 << 9),
PT_SUPPRESS_INDEX = (0x1 << 10),
PT_SUPPRESS_ORDERING = (0x1 << 11),
PT_PRINT_QUOTES = (0x1 << 12),
/* PT_FORCE_ORIGINAL_TABLE_NAME is for PT_NAME nodes. prints original table name instead of printing resolved NOTE:
* spec_id must point to original table */
PT_FORCE_ORIGINAL_TABLE_NAME = (0x1 << 13),
PT_SUPPRESS_CHARSET_PRINT = (0x1 << 14),
/* PT_PRINT_DIFFERENT_SYSTEM_PARAMETERS print session parameters */
PT_PRINT_DIFFERENT_SYSTEM_PARAMETERS = (0x1 << 15),
/* PT_NODE_PRINT_TO_ALIAS calls pt_short_print instead pt_print_tree */
PT_SHORT_PRINT = (0x1 << 16),
PT_SUPPRESS_BIGINT_CAST = (0x1 << 17),
PT_CHARSET_COLLATE_FULL = (0x1 << 18),
PT_CHARSET_COLLATE_USER_ONLY = (0x1 << 19),
PT_PRINT_USER = (0x1 << 20),
PT_PRINT_ORIGINAL_BEFORE_CONST_FOLDING = (0x1 << 21),
PT_PRINT_NO_HOST_VAR_INDEX = (0x1 << 22),
/* Both PT_PRINT_NO_SPECIFIED_USER_NAME and PT_PRINT_NO_CURRENT_USER_NAME can be set.
* Check PT_PRINT_NO_SPECIFIED_USER_NAME before PT_PRINT_NO_CURRENT_USER_NAME to set implicit priority. */
PT_PRINT_NO_SPECIFIED_USER_NAME = (0x1 << 23),
PT_PRINT_NO_CURRENT_USER_NAME = (0x1 << 24),
/* the '@' sign has to be suppressed during printing remote-table speicification for pure remote query */
PT_PRINT_SUPPRESS_SERVER_NAME = (0x1 << 25),
/* suppress next_value to serial_next_value(...) or current_value to serial_current_value(...) */
PT_PRINT_SUPPRESS_SERIAL_CONV = (0x1 << 26),
/* suppress print various generated functions including suppress delete targe for dblink */
PT_PRINT_SUPPRESS_FOR_DBLINK = (0x1 << 27),
PT_PRINT_HOST_VAR_COUNT = (0x1 << 28),
PT_PRINT_DBLINK_INFO = (0x1 << 29), /* If you use DBLINK, specify it when generating the SHA hash value. */
/* print lower case */
PT_PRINT_LOWER = (0x1 << 30)
};
/* all statement node types should be assigned their API statement enumeration */
enum pt_node_type
{
PT_NODE_NONE = CUBRID_STMT_NONE,
PT_ALTER = CUBRID_STMT_ALTER_CLASS,
PT_ALTER_INDEX = CUBRID_STMT_ALTER_INDEX,
PT_ALTER_USER = CUBRID_STMT_ALTER_USER,
PT_ALTER_SERIAL = CUBRID_STMT_ALTER_SERIAL,
PT_COMMIT_WORK = CUBRID_STMT_COMMIT_WORK,
PT_CREATE_ENTITY = CUBRID_STMT_CREATE_CLASS,
PT_CREATE_INDEX = CUBRID_STMT_CREATE_INDEX,
PT_CREATE_USER = CUBRID_STMT_CREATE_USER,
PT_CREATE_TRIGGER = CUBRID_STMT_CREATE_TRIGGER,
PT_CREATE_SERIAL = CUBRID_STMT_CREATE_SERIAL,
PT_DROP = CUBRID_STMT_DROP_CLASS,
PT_DROP_INDEX = CUBRID_STMT_DROP_INDEX,
PT_DROP_USER = CUBRID_STMT_DROP_USER,
PT_DROP_VARIABLE = CUBRID_STMT_DROP_LABEL,
PT_DROP_TRIGGER = CUBRID_STMT_DROP_TRIGGER,
PT_DROP_SERIAL = CUBRID_STMT_DROP_SERIAL,
PT_EVALUATE = CUBRID_STMT_EVALUATE,
PT_RENAME = CUBRID_STMT_RENAME_CLASS,
PT_ROLLBACK_WORK = CUBRID_STMT_ROLLBACK_WORK,
PT_GRANT = CUBRID_STMT_GRANT,
PT_REVOKE = CUBRID_STMT_REVOKE,
PT_UPDATE_STATS = CUBRID_STMT_UPDATE_STATS,
PT_GET_STATS = CUBRID_STMT_GET_STATS,
PT_INSERT = CUBRID_STMT_INSERT,
PT_SELECT = CUBRID_STMT_SELECT,
PT_UPDATE = CUBRID_STMT_UPDATE,
PT_DELETE = CUBRID_STMT_DELETE,
PT_METHOD_CALL = CUBRID_STMT_CALL,
PT_GET_XACTION = CUBRID_STMT_GET_ISO_LVL,
/* should have separate pt node type for CUBRID_STMT_GET_TIMEOUT, It will also be tagged PT_GET_XACTION */
PT_GET_OPT_LVL = CUBRID_STMT_GET_OPT_LVL,
PT_SET_OPT_LVL = CUBRID_STMT_SET_OPT_LVL,
PT_SET_SYS_PARAMS = CUBRID_STMT_SET_SYS_PARAMS,
PT_SCOPE = CUBRID_STMT_SCOPE,
PT_SET_TRIGGER = CUBRID_STMT_SET_TRIGGER,
PT_GET_TRIGGER = CUBRID_STMT_GET_TRIGGER,
PT_SAVEPOINT = CUBRID_STMT_SAVEPOINT,
PT_PREPARE_TO_COMMIT = CUBRID_STMT_PREPARE,
PT_2PC_ATTACH = CUBRID_STMT_ATTACH,
#if defined (ENABLE_UNUSED_FUNCTION)
PT_USE = CUBRID_STMT_USE,
#endif
PT_REMOVE_TRIGGER = CUBRID_STMT_REMOVE_TRIGGER,
PT_RENAME_TRIGGER = CUBRID_STMT_RENAME_TRIGGER,
PT_CREATE_STORED_PROCEDURE = CUBRID_STMT_CREATE_STORED_PROCEDURE,
PT_ALTER_STORED_PROCEDURE = CUBRID_STMT_ALTER_STORED_PROCEDURE,
PT_DROP_STORED_PROCEDURE = CUBRID_STMT_DROP_STORED_PROCEDURE,
PT_PREPARE_STATEMENT = CUBRID_STMT_PREPARE_STATEMENT,
PT_EXECUTE_PREPARE = CUBRID_STMT_EXECUTE_PREPARE,
PT_DEALLOCATE_PREPARE = CUBRID_STMT_DEALLOCATE_PREPARE,
PT_TRUNCATE = CUBRID_STMT_TRUNCATE,
PT_DO = CUBRID_STMT_DO,
PT_SET_SESSION_VARIABLES = CUBRID_STMT_SET_SESSION_VARIABLES,
PT_DROP_SESSION_VARIABLES = CUBRID_STMT_DROP_SESSION_VARIABLES,
PT_MERGE = CUBRID_STMT_MERGE,
PT_SET_NAMES = CUBRID_STMT_SET_NAMES,
PT_SET_TIMEZONE = CUBRID_STMT_SET_TIMEZONE,
PT_CREATE_SERVER = CUBRID_STMT_CREATE_SERVER,
PT_DROP_SERVER = CUBRID_STMT_DROP_SERVER,
PT_RENAME_SERVER = CUBRID_STMT_RENAME_SERVER,
PT_ALTER_SERVER = CUBRID_STMT_ALTER_SERVER,
PT_ALTER_SYNONYM = CUBRID_STMT_ALTER_SYNONYM,
PT_CREATE_SYNONYM = CUBRID_STMT_CREATE_SYNONYM,
PT_DROP_SYNONYM = CUBRID_STMT_DROP_SYNONYM,
PT_RENAME_SYNONYM = CUBRID_STMT_RENAME_SYNONYM,
PT_DIFFERENCE = CUBRID_MAX_STMT_TYPE, /* these enumerations must be distinct from statements */
PT_INTERSECTION, /* difference intersection and union are reported as CUBRID_STMT_SELECT. */
PT_UNION,
PT_ZZ_ERROR_MSG,
PT_ALTER_TRIGGER,
PT_ATTR_DEF,
PT_AUTH_CMD,
PT_AUTO_INCREMENT,
PT_CHECK_OPTION,
PT_CONSTRAINT,
PT_CTE,
PT_DATA_DEFAULT,
PT_DATA_TYPE,
PT_DOT_,
PT_EVENT_OBJECT,
PT_EVENT_SPEC,
PT_EVENT_TARGET,
PT_EXECUTE_TRIGGER,
PT_EXPR,
PT_FILE_PATH,
PT_FUNCTION,
PT_HOST_VAR,
PT_ISOLATION_LVL,
PT_METHOD_DEF,
PT_NAME,
PT_PARTITION,
PT_PARTS,
PT_RESOLUTION,
PT_SET_XACTION,
PT_SORT_SPEC,
PT_SP_PARAMETERS,
PT_SPEC,
PT_TIMEOUT,
PT_TRIGGER_ACTION,
PT_TRIGGER_SPEC_LIST,
PT_VALUE,
PT_NODE_POINTER,
PT_NODE_LIST,
PT_TABLE_OPTION,
PT_ATTR_ORDERING,
PT_TUPLE_VALUE,
PT_QUERY_TRACE,
PT_INSERT_VALUE,
PT_NAMED_ARG,
PT_SHOWSTMT,
PT_KILL_STMT,
PT_VACUUM,
PT_WITH_CLAUSE,
PT_JSON_TABLE,
PT_JSON_TABLE_NODE,
PT_JSON_TABLE_COLUMN,
PT_DBLINK_TABLE,
PT_DBLINK_TABLE_DML,
PT_SP_BODY,
PT_NODE_NUMBER, /* This is the number of node types */
PT_LAST_NODE_NUMBER = PT_NODE_NUMBER
};
typedef enum pt_node_type PT_NODE_TYPE;
/* Enumerated Data Types for expressions with a VALUE */
enum pt_type_enum
{
PT_TYPE_NONE = 1000, /* type not known yet */
PT_TYPE_MIN = PT_TYPE_NONE,
/* primitive types */
PT_TYPE_INTEGER,
PT_TYPE_FLOAT,
PT_TYPE_DOUBLE,
PT_TYPE_SMALLINT,
PT_TYPE_DATE,
PT_TYPE_TIME,
PT_TYPE_TIMESTAMP,
PT_TYPE_DATETIME,
PT_TYPE_MONETARY,
PT_TYPE_NUMERIC,
PT_TYPE_CHAR,
PT_TYPE_VARCHAR,
/* TODO:
* DB_TYPE_NCHAR and DB_TYPE_VARNCHAR will no longer be used(NCHAR was deprecated).
* However, to maintain compatibility with previous versions, the enum list will be preserved.
*/
PT_TYPE_NCHAR_DEPRECATED,
PT_TYPE_VARNCHAR_DEPRECATED,
PT_TYPE_BIT,
PT_TYPE_VARBIT,
PT_TYPE_LOGICAL,
PT_TYPE_MAYBE,
PT_TYPE_JSON,
/* special values */
PT_TYPE_NA, /* in SELECT NA */
PT_TYPE_NULL, /* in assignment and defaults */
PT_TYPE_STAR, /* select (*), count (*), will be expanded later */
/* non primitive types */
PT_TYPE_OBJECT,
PT_TYPE_SET,
PT_TYPE_MULTISET,
PT_TYPE_SEQUENCE,
PT_TYPE_MIDXKEY,
PT_TYPE_COMPOUND,
PT_TYPE_EXPR_SET, /* type of parentheses expr set, avail for parser only */
PT_TYPE_RESULTSET,
PT_TYPE_BIGINT,
PT_TYPE_BLOB,
PT_TYPE_CLOB,
PT_TYPE_ELO,
PT_TYPE_ENUMERATION,
PT_TYPE_TIMESTAMPLTZ,
PT_TYPE_TIMESTAMPTZ,
PT_TYPE_DATETIMETZ,
PT_TYPE_DATETIMELTZ,
PT_TYPE_MAX,
PT_TYPE_TABLE_COLUMN, /* not a real type but a type specification of the form <table>.<column>%TYPE */
/* which can be used only in SP parameter and return types */
};
typedef enum pt_type_enum PT_TYPE_ENUM;
/* Enumerated priviledges for Grant, Revoke */
typedef enum
{
PT_NO_PRIV = 2000, /* this value to initialize the node */
PT_ADD_PRIV,
PT_ALL_PRIV,
PT_ALTER_PRIV,
PT_DELETE_PRIV,
PT_DROP_PRIV,
PT_EXECUTE_PRIV,
/* PT_GRANT_OPTION_PRIV, avail for revoke only */
PT_INDEX_PRIV,
PT_INSERT_PRIV,
PT_REFERENCES_PRIV, /* for ANSI compatibility */
PT_SELECT_PRIV,
PT_UPDATE_PRIV,
PT_EXECUTE_PROCEDURE_PRIV
} PT_PRIV_TYPE;
/* Enumerated join type */
typedef enum
{
PT_JOIN_NONE = 0x00, /* 0000 0000 */
PT_JOIN_CROSS = 0x01, /* 0000 0001 */
PT_JOIN_NATURAL = 0x02, /* 0000 0010 -- not used */
PT_JOIN_INNER = 0x04, /* 0000 0100 */
PT_JOIN_LEFT_OUTER = 0x08, /* 0000 1000 */
PT_JOIN_RIGHT_OUTER = 0x10, /* 0001 0000 */
PT_JOIN_FULL_OUTER = 0x20, /* 0010 0000 -- not used */
PT_JOIN_UNION = 0x40 /* 0100 0000 -- not used */
} PT_JOIN_TYPE;
typedef UINT64 PT_HINT_ENUM;
#define PT_HINT_NONE (0ULL ) /* no hint */
#define PT_HINT_ORDERED (1ULL << 0) /* force join left-to-right */
#define PT_HINT_NO_INDEX_SS (1ULL << 1) /* disable index skip scan */
#define PT_HINT_INDEX_SS (1ULL << 2) /* enable index skip scan */
#define PT_HINT_SELECT_BTREE_NODE_INFO (1ULL << 3) /* SELECT b-tree node information */
#define PT_HINT_USE_NL (1ULL << 4) /* force nl-join */
#define PT_HINT_USE_IDX (1ULL << 5) /* force idx-join */
#define PT_HINT_USE_MERGE (1ULL << 6) /* force m-join */
#define PT_HINT_USE_HASH (1ULL << 7) /* force hash-join */
#define PT_HINT_RECOMPILE (1ULL << 8) /* recompile */
#define PT_HINT_LK_TIMEOUT (1ULL << 9) /* lock_timeout */
#define PT_HINT_NO_LOGGING (1ULL << 10) /* no_logging */
#define PT_HINT_NO_HASH_LIST_SCAN (1ULL << 11) /* no hash list scan */
#define PT_HINT_QUERY_CACHE (1ULL << 12) /* query_cache */
#define PT_HINT_REEXECUTE (1ULL << 13) /* reexecute */
#define PT_HINT_JDBC_CACHE (1ULL << 14) /* jdbc_cache */
#define PT_HINT_USE_SBR (1ULL << 15) /* statement based replication */
#define PT_HINT_USE_IDX_DESC (1ULL << 16) /* descending index scan */
#define PT_HINT_NO_COVERING_IDX (1ULL << 17) /* do not use covering index scan */
#define PT_HINT_INSERT_MODE (1ULL << 18) /* set insert_executeion_mode */
#define PT_HINT_NO_IDX_DESC (1ULL << 19) /* do not use descending index scan */
#define PT_HINT_NO_MULTI_RANGE_OPT (1ULL << 20) /* do not use multi range optimization */
#define PT_HINT_USE_UPDATE_IDX (1ULL << 21) /* use index for merge update */
#define PT_HINT_USE_INSERT_IDX (1ULL << 22) /* do not generate SORT-LIMIT plan */
#define PT_HINT_NO_SORT_LIMIT (1ULL << 23)
#define PT_HINT_NO_HASH_AGGREGATE (1ULL << 24) /* no hash aggregate evaluation */
#define PT_HINT_SKIP_UPDATE_NULL (1ULL << 25)
#define PT_HINT_NO_INDEX_LS (1ULL << 26) /* disable loose index scan */
#define PT_HINT_INDEX_LS (1ULL << 27) /* enable loose index scan */
#define PT_HINT_NO_SUPPLEMENTAL_LOG (1ULL << 28) /* Used in DML (only for update delete currently) to avoid adding DML supplemental logs that may be duplicated by DDL */
#define PT_HINT_SELECT_RECORD_INFO (1ULL << 29) /* SELECT record info from tuple header instead of data */
#define PT_HINT_SELECT_PAGE_INFO (1ULL << 30) /* SELECT page header information from heap file instead of record data */
#define PT_HINT_SELECT_KEY_INFO (1ULL << 31) /* SELECT key information from index b-tree instead of table record data */
#define PT_HINT_QUERY_NO_CACHE (1ULL << 32) /* don't use the query cache (unused) */
#define PT_HINT_NO_PUSH_PRED (1ULL << 33) /* do not push predicates */
#define PT_HINT_NO_MERGE (1ULL << 34) /* do not merge view or in-line view */
#define PT_HINT_NO_ELIMINATE_JOIN (1ULL << 35) /* do not eliminate join */
#define PT_HINT_SAMPLING_SCAN (1ULL << 36) /* SELECT sampling data instead of full data */
#define PT_HINT_LEADING (1ULL << 37) /* force specific table to join left-to-right */
#define PT_HINT_NO_SUBQUERY_CACHE (1ULL << 38) /* don't use the subquery result cache */
#define PT_HINT_NO_USE_HASH (1ULL << 39) /* disable hash-join */
#define PT_HINT_NO_PARALLEL_HEAP_SCAN (1ULL << 40) /* disable parallel heap scan */
#define PT_HINT_PARALLEL (1ULL << 41) /* parallel query execution threads */
#define PT_HINT_INLINE_CTE (1ULL << 42) /* inline CTE */
#define PT_HINT_MATERIALIZE_CTE (1ULL << 43) /* materialize CTE */
#define PT_HINT_NO_PARALLEL_SUBQUERY (1ULL << 44) /* disable parallel subquery */
#define PT_HINT_NO_PARALLEL_HASH_JOIN (1ULL << 45) /* disable parallel hash join */
#define PT_HINT_NLJ_KEEP_HEAP_PAGE_PINNED (1ULL << 46) /* keep page fixed on nl join first table heap scan */
/* Codes for error messages */
typedef enum
{
PT_NO_ERROR = 4000,
PT_USAGE,
PT_NODE_TABLE_OVERFLOW,
PT_NAMES_TABLE_OVERFLOW,
PT_CANT_OPEN_FILE,
PT_STACK_OVERFLOW,
PT_STACK_UNDERFLOW,
PT_PARSE_ERROR,
PT_ILLEGAL_TYPE_IN_FUNC,
PT_NO_ARG_IN_FUNC
} PT_ERROR_CODE;
/* Codes for alter/add */
typedef enum
{
PT_ADD_QUERY = 5000,
PT_DROP_QUERY,
PT_MODIFY_QUERY,
PT_RESET_QUERY,
PT_ADD_ATTR_MTHD,
PT_DROP_ATTR_MTHD,
PT_MODIFY_ATTR_MTHD,
PT_RENAME_ATTR_MTHD,
PT_MODIFY_DEFAULT,
PT_ADD_SUPCLASS,
PT_DROP_SUPCLASS,
PT_DROP_RESOLUTION,
PT_RENAME_RESOLUTION,
PT_DROP_CONSTRAINT,
PT_APPLY_PARTITION,
PT_DROP_PARTITION,
PT_REMOVE_PARTITION,
PT_ADD_PARTITION,
PT_ADD_HASHPARTITION,
PT_REORG_PARTITION,
PT_COALESCE_PARTITION,
PT_ANALYZE_PARTITION,
PT_PROMOTE_PARTITION,
PT_RENAME_ENTITY,
PT_ALTER_DEFAULT,
PT_DROP_INDEX_CLAUSE,
PT_DROP_PRIMARY_CLAUSE,
PT_DROP_FK_CLAUSE,
PT_CHANGE_ATTR,
PT_CHANGE_AUTO_INCREMENT,
PT_CHANGE_OWNER,
PT_CHANGE_COLLATION,
#if defined (ENABLE_RENAME_CONSTRAINT)
PT_RENAME_CONSTRAINT,
PT_RENAME_INDEX,
#endif
PT_REBUILD_INDEX,
PT_ADD_INDEX_CLAUSE,
PT_CHANGE_TABLE_COMMENT,
PT_CHANGE_COLUMN_COMMENT,
PT_CHANGE_INDEX_COMMENT,
PT_CHANGE_INDEX_STATUS,
PT_ADD_MEMBERS, /* alter user type */
PT_DROP_MEMBERS,
PT_SERIAL_OPTION /* alter serial type */
} PT_ALTER_CODE;
/* Codes for trigger event type */
typedef enum
{
PT_EV_INSERT = 6000,
PT_EV_STMT_INSERT,
PT_EV_DELETE,
PT_EV_STMT_DELETE,
PT_EV_UPDATE,
PT_EV_STMT_UPDATE,
PT_EV_ALTER,
PT_EV_DROP,
PT_EV_COMMIT,
PT_EV_ROLLBACK,
PT_EV_ABORT,
PT_EV_TIMEOUT
} PT_EVENT_TYPE;
/* Codes for constraint types */
typedef enum
{
PT_CONSTRAIN_UNKNOWN = 7000,
PT_CONSTRAIN_PRIMARY_KEY,
PT_CONSTRAIN_FOREIGN_KEY,
PT_CONSTRAIN_NULL,
PT_CONSTRAIN_NOT_NULL,
PT_CONSTRAIN_UNIQUE,
PT_CONSTRAIN_CHECK
} PT_CONSTRAINT_TYPE;
typedef enum
{
PT_PARTITION_HASH = 0,
PT_PARTITION_RANGE,
PT_PARTITION_LIST
} PT_PARTITION_TYPE;
typedef enum
{
PT_TABLE_OPTION_NONE = 0,
PT_TABLE_OPTION_REUSE_OID = 9000,
PT_TABLE_OPTION_AUTO_INCREMENT,
PT_TABLE_OPTION_CHARSET,
PT_TABLE_OPTION_COLLATION,
PT_TABLE_OPTION_COMMENT,
PT_TABLE_OPTION_ENCRYPT,
PT_TABLE_OPTION_DONT_REUSE_OID
} PT_TABLE_OPTION_TYPE;
typedef enum
{
PT_AND = 400, PT_OR, PT_NOT,
PT_BETWEEN, PT_NOT_BETWEEN,
PT_LIKE, PT_NOT_LIKE,
PT_IS_IN, PT_IS_NOT_IN,
PT_IS_NULL, PT_IS_NOT_NULL,
PT_IS, PT_IS_NOT,
PT_EXISTS,
PT_EQ_SOME, PT_NE_SOME, PT_GE_SOME, PT_GT_SOME, PT_LT_SOME, PT_LE_SOME,
PT_EQ_ALL, PT_NE_ALL, PT_GE_ALL, PT_GT_ALL, PT_LT_ALL, PT_LE_ALL,
PT_EQ, PT_NE, PT_GE, PT_GT, PT_LT, PT_LE, PT_NULLSAFE_EQ,
PT_GT_INF, PT_LT_INF, /* internal use only */
PT_SETEQ, PT_SETNEQ, PT_SUPERSETEQ, PT_SUPERSET, PT_SUBSET, PT_SUBSETEQ,
PT_PLUS, PT_MINUS,
PT_TIMES, PT_DIVIDE, PT_UNARY_MINUS, PT_PRIOR, PT_QPRIOR,
PT_CONNECT_BY_ROOT,
PT_BIT_NOT, PT_BIT_XOR, PT_BIT_AND, PT_BIT_OR, PT_BIT_COUNT,
PT_BITSHIFT_LEFT, PT_BITSHIFT_RIGHT, PT_DIV, PT_MOD,
PT_IF, PT_IFNULL, PT_ISNULL, PT_XOR,
PT_ASSIGN, /* as in x=y */
PT_BETWEEN_AND,
PT_BETWEEN_GE_LE, PT_BETWEEN_GE_LT, PT_BETWEEN_GT_LE, PT_BETWEEN_GT_LT,
PT_BETWEEN_EQ_NA,
PT_BETWEEN_INF_LE, PT_BETWEEN_INF_LT, PT_BETWEEN_GE_INF, PT_BETWEEN_GT_INF,
PT_RANGE, /* internal use only */
PT_MODULUS, PT_RAND, PT_DRAND,
PT_POSITION, PT_SUBSTRING, PT_OCTET_LENGTH, PT_BIT_LENGTH,
PT_SUBSTRING_INDEX, PT_MD5, PT_SPACE,
PT_CHAR_LENGTH, PT_LOWER, PT_UPPER, PT_TRIM,
PT_LTRIM, PT_RTRIM, PT_LPAD, PT_RPAD, PT_REPLACE, PT_TRANSLATE,
PT_REPEAT,
PT_ADD_MONTHS, PT_LAST_DAY, PT_MONTHS_BETWEEN, PT_SYS_DATE,
PT_TO_CHAR, PT_TO_DATE, PT_TO_NUMBER,
PT_SYS_TIME, PT_SYS_TIMESTAMP, PT_CURRENT_TIMESTAMP, PT_SYS_DATETIME,
PT_CURRENT_DATETIME, PT_CURRENT_TIME, PT_CURRENT_DATE, PT_UTC_TIME,
PT_UTC_DATE, PT_TO_TIME, PT_TO_TIMESTAMP, PT_TO_DATETIME,
PT_CURRENT_VALUE, PT_NEXT_VALUE,
PT_INST_NUM, PT_ROWNUM, PT_ORDERBY_NUM,
PT_CONNECT_BY_ISCYCLE, PT_CONNECT_BY_ISLEAF, PT_LEVEL,
PT_SYS_CONNECT_BY_PATH,
PT_EXTRACT,
PT_LIKE_ESCAPE,
PT_CAST,
PT_CASE,
PT_CURRENT_USER,
PT_LOCAL_TRANSACTION_ID,
PT_FLOOR, PT_CEIL, PT_SIGN, PT_POWER, PT_ROUND, PT_ABS, PT_TRUNC,
PT_CHR, PT_INSTR, PT_LEAST, PT_GREATEST,
PT_PATH_EXPR_SET,
PT_ENCRYPT, PT_DECRYPT,
PT_STRCAT, PT_NULLIF, PT_COALESCE, PT_NVL, PT_NVL2, PT_DECODE,
PT_RANDOM, PT_DRANDOM,
PT_INCR, PT_DECR,
PT_LOG, PT_EXP, PT_SQRT,
PT_CONCAT, PT_CONCAT_WS, PT_FIELD, PT_LEFT, PT_RIGHT,
PT_LOCATE, PT_MID, PT_STRCMP, PT_REVERSE,
PT_ACOS, PT_ASIN, PT_ATAN, PT_ATAN2,
PT_COS, PT_SIN, PT_COT, PT_TAN,
PT_DEGREES, PT_RADIANS,
PT_PI,
PT_FORMAT,
PT_DISK_SIZE,
PT_LN, PT_LOG2, PT_LOG10,
PT_TIME_FORMAT,
PT_TIMESTAMP,
PT_UNIX_TIMESTAMP,
PT_FROM_UNIXTIME,
PT_SCHEMA,
PT_DATABASE,
PT_VERSION,
/* datetime */
PT_ADDDATE, /* 2 fixed parameter */
PT_DATE_ADD, /* INTERVAL variant */
PT_SUBDATE,
PT_DATE_SUB,
PT_DATE_FORMAT,
PT_DATEF,
PT_TIMEF, PT_YEARF, PT_MONTHF, PT_DAYF,
PT_HOURF, PT_MINUTEF, PT_SECONDF,
PT_DAYOFMONTH,
PT_WEEKDAY,
PT_DAYOFWEEK,
PT_DAYOFYEAR,
PT_QUARTERF,
PT_TODAYS,
PT_FROMDAYS,
PT_TIMETOSEC,
PT_SECTOTIME,
PT_MAKEDATE,
PT_MAKETIME,
PT_WEEKF,
PT_USER,
PT_ROW_COUNT,
PT_LAST_INSERT_ID,
PT_DATEDIFF,
PT_TIMEDIFF,
PT_STR_TO_DATE,
PT_DEFAULTF,
PT_LIST_DBS,
PT_OID_OF_DUPLICATE_KEY,
PT_LIKE_LOWER_BOUND, PT_LIKE_UPPER_BOUND,
PT_BIT_TO_BLOB, PT_BLOB_FROM_FILE, PT_BLOB_LENGTH, PT_BLOB_TO_BIT,
PT_CHAR_TO_BLOB, PT_CHAR_TO_CLOB, PT_CLOB_FROM_FILE, PT_CLOB_LENGTH,
PT_CLOB_TO_CHAR,
PT_TYPEOF,
PT_FUNCTION_HOLDER, /* special operator : wrapper for PT_FUNCTION node */
PT_INDEX_CARDINALITY,
PT_DEFINE_VARIABLE,
PT_EVALUATE_VARIABLE,
PT_EXEC_STATS,
PT_ADDTIME,
PT_BIN,
PT_FINDINSET,
PT_HEX,
PT_ASCII,
PT_CONV,
/* rlike operator */
PT_RLIKE, PT_NOT_RLIKE, PT_RLIKE_BINARY, PT_NOT_RLIKE_BINARY,
PT_TO_ENUMERATION_VALUE,
/* inet */
PT_INET_ATON, PT_INET_NTOA,
PT_CHARSET, PT_COERCIBILITY, PT_COLLATION,
/* width_bucket */
PT_WIDTH_BUCKET,
PT_TRACE_STATS,
PT_INDEX_PREFIX,
PT_AES_ENCRYPT,
PT_AES_DECRYPT,
PT_SHA_ONE,
PT_SHA_TWO,
PT_TO_BASE64,
PT_FROM_BASE64,
PT_SLEEP,
PT_SYS_GUID,
PT_DBTIMEZONE,
PT_SESSIONTIMEZONE,
PT_TZ_OFFSET,
PT_NEW_TIME,
PT_FROM_TZ,
PT_TO_DATETIME_TZ,
PT_TO_TIMESTAMP_TZ,
PT_UTC_TIMESTAMP,
PT_CRC32,
PT_SCHEMA_DEF,
PT_CONV_TZ,
/* This is the last entry. Please add a new one before it. */
PT_LAST_OPCODE
} PT_OP_TYPE;
/* the virtual query mechanism needs to put oid columns on non-updatable
* virtual query guys, hence the "trust me" part.
*/
typedef enum
{
PT_NO_OID_INCLUDED,
PT_INCLUDE_OID,
PT_INCLUDE_OID_TRUSTME
} PT_INCLUDE_OID_TYPE;
typedef enum
{
PT_RANGE_MERGE,
PT_RANGE_INTERSECTION,
PT_REDUCE_COMP_PAIR_TERMS
} PT_COMP_TO_BETWEEN_OP_CODE_TYPE;
typedef enum
{
PT_SYNTAX,
PT_SEMANTIC,
PT_EXECUTION
} PT_ERROR_TYPE;
typedef enum
{
EXCLUDE_HIDDEN_COLUMNS,
INCLUDE_HIDDEN_COLUMNS
} PT_INCLUDE_OR_EXCLUDE_HIDDEN_COLUMNS;
/* Flags for spec structures */
typedef enum
{
PT_SPEC_FLAG_NONE = 0x0, /* the spec will not be altered */
PT_SPEC_FLAG_UPDATE = 0x01, /* the spec will be updated */
PT_SPEC_FLAG_DELETE = 0x02, /* the spec will be deleted */
PT_SPEC_FLAG_HAS_UNIQUE = 0x04, /* the spec has unique */
PT_SPEC_FLAG_FROM_VCLASS = 0x08, /* applicable for derived tables, marks one as a rewritten view */
PT_SPEC_FLAG_CONTAINS_OID = 0x10, /* classoid and oid were added in the derived table's select list */
PT_SPEC_FLAG_FOR_UPDATE_CLAUSE = 0x20, /* Used with FOR UPDATE clause */
PT_SPEC_FLAG_RECORD_INFO_SCAN = 0x40, /* spec will be scanned for record information instead of record data */
PT_SPEC_FLAG_PAGE_INFO_SCAN = 0x80, /* spec's heap file will scanned page by page for page information. records
* will not be scanned. */
PT_SPEC_FLAG_KEY_INFO_SCAN = 0x100, /* one of the spec's indexes will be scanned for key information. */
PT_SPEC_FLAG_BTREE_NODE_INFO_SCAN = 0x200, /* one of the spec's indexes will be scanned for b-tree node info */
PT_SPEC_FLAG_MVCC_COND_REEV = 0x400, /* the spec is used in mvcc condition reevaluation */
PT_SPEC_FLAG_MVCC_ASSIGN_REEV = 0x800, /* the spec is used in UPDATE assignment reevaluation */
PT_SPEC_FLAG_DOESNT_HAVE_UNIQUE = 0x1000, /* the spec was checked and does not have any uniques */
PT_SPEC_FLAG_SAMPLING_SCAN = 0x2000, /* spec for sampling scan */
PT_SPEC_FLAG_REFERENCED_AT_ODKU = 0x4000, /* spec for odku assignment */
PT_SPEC_FLAG_NO_PARALLEL_HEAP_SCAN = 0x8000, /* spec for not for parallel heap scan */
PT_SPEC_FLAG_PARALLEL_THREAD = 0x10000 /* spec for setted number of parallel query execution threads */
} PT_SPEC_FLAG;
typedef enum
{
CONNECT_BY_CYCLES_ERROR = 0,
CONNECT_BY_CYCLES_NONE,
CONNECT_BY_CYCLES_IGNORE,
CONNECT_BY_CYCLES_NONE_IGNORE
} PT_CONNECT_BY_CHECK_CYCLES;
/* Enum used for insert statements. After checking if insert is allowed on
* server, the result is saved to avoid the same check again.
*/
typedef enum
{
SERVER_INSERT_NOT_CHECKED = 0,
SERVER_INSERT_IS_ALLOWED = 1,
SERVER_INSERT_IS_NOT_ALLOWED = -1
} SERVER_INSERT_ALLOWED;
/*
* Type definitions
*/
typedef struct parser_varchar PARSER_VARCHAR;
typedef struct parser_context PARSER_CONTEXT;
typedef struct parser_node PT_NODE;
typedef struct pt_alter_info PT_ALTER_INFO;
typedef struct pt_alter_user_info PT_ALTER_USER_INFO;
typedef struct pt_alter_trigger_info PT_ALTER_TRIGGER_INFO;
typedef struct pt_attach_info PT_ATTACH_INFO;
typedef struct pt_attach_info PT_PREPARE_TO_COMMIT_INFO;
typedef struct pt_attr_def_info PT_ATTR_DEF_INFO;
typedef struct pt_attr_ordering_info PT_ATTR_ORDERING_INFO;
typedef struct pt_auth_cmd_info PT_AUTH_CMD_INFO;
typedef struct pt_commit_work_info PT_COMMIT_WORK_INFO;
typedef struct pt_create_entity_info PT_CREATE_ENTITY_INFO;
typedef struct pt_index_info PT_INDEX_INFO;
typedef struct pt_create_user_info PT_CREATE_USER_INFO;
typedef struct pt_create_trigger_info PT_CREATE_TRIGGER_INFO;
typedef struct pt_cte_info PT_CTE_INFO;
typedef struct pt_serial_info PT_SERIAL_INFO;
typedef struct pt_data_default_info PT_DATA_DEFAULT_INFO;
typedef struct pt_auto_increment_info PT_AUTO_INCREMENT_INFO;
typedef struct pt_partition_info PT_PARTITION_INFO;
typedef struct pt_parts_info PT_PARTS_INFO;
typedef struct pt_data_type_info PT_DATA_TYPE_INFO;
typedef struct pt_delete_info PT_DELETE_INFO;
typedef struct pt_dot_info PT_DOT_INFO;
typedef struct pt_drop_info PT_DROP_INFO;
typedef struct pt_drop_user_info PT_DROP_USER_INFO;
typedef struct pt_drop_trigger_info PT_DROP_TRIGGER_INFO;
typedef struct pt_drop_variable_info PT_DROP_VARIABLE_INFO;
typedef struct pt_drop_session_var_info PT_DROP_SESSION_VAR_INFO;
typedef struct pt_spec_info PT_SPEC_INFO;
typedef struct pt_evaluate_info PT_EVALUATE_INFO;
typedef struct pt_event_object_info PT_EVENT_OBJECT_INFO;
typedef struct pt_event_spec_info PT_EVENT_SPEC_INFO;
typedef struct pt_event_target_info PT_EVENT_TARGET_INFO;
typedef struct pt_execute_trigger_info PT_EXECUTE_TRIGGER_INFO;
typedef struct pt_expr_info PT_EXPR_INFO;
typedef struct pt_file_path_info PT_FILE_PATH_INFO;
typedef struct pt_function_info PT_FUNCTION_INFO;
typedef struct pt_get_opt_lvl_info PT_GET_OPT_LVL_INFO;
typedef struct pt_get_trigger_info PT_GET_TRIGGER_INFO;
typedef struct pt_get_xaction_info PT_GET_XACTION_INFO;
typedef struct pt_grant_info PT_GRANT_INFO;
typedef struct pt_host_var_info PT_HOST_VAR_INFO;
typedef struct pt_insert_info PT_INSERT_INFO;
typedef struct pt_isolation_lvl_info PT_ISOLATION_LVL_INFO;
typedef struct pt_merge_info PT_MERGE_INFO;
typedef struct pt_method_call_info PT_METHOD_CALL_INFO;
typedef struct pt_method_def_info PT_METHOD_DEF_INFO;
typedef struct pt_name_info PT_NAME_INFO;
typedef struct pt_named_arg_info PT_NAMED_ARG_INFO;
typedef struct pt_remove_trigger_info PT_REMOVE_TRIGGER_INFO;
typedef struct pt_rename_info PT_RENAME_INFO;
typedef struct pt_rename_trigger_info PT_RENAME_TRIGGER_INFO;
typedef struct pt_resolution_info PT_RESOLUTION_INFO;
typedef struct pt_revoke_info PT_REVOKE_INFO;
typedef struct pt_rollback_work_info PT_ROLLBACK_WORK_INFO;
typedef struct pt_union_info PT_UNION_INFO;
typedef struct pt_savepoint_info PT_SAVEPOINT_INFO;
typedef struct pt_scope_info PT_SCOPE_INFO;
typedef struct pt_select_info PT_SELECT_INFO;
typedef struct pt_query_info PT_QUERY_INFO;
typedef struct pt_set_opt_lvl_info PT_SET_OPT_LVL_INFO;
typedef struct pt_set_sys_params_info PT_SET_SYS_PARAMS_INFO;
typedef struct pt_set_xaction_info PT_SET_XACTION_INFO;
typedef struct pt_set_trigger_info PT_SET_TRIGGER_INFO;
typedef struct pt_showstmt_info PT_SHOWSTMT_INFO;
typedef struct pt_killstmt_info PT_KILLSTMT_INFO;
typedef struct pt_sort_spec_info PT_SORT_SPEC_INFO;
typedef struct pt_timeout_info PT_TIMEOUT_INFO;
typedef struct pt_trigger_action_info PT_TRIGGER_ACTION_INFO;
typedef struct pt_trigger_spec_list_info PT_TRIGGER_SPEC_LIST_INFO;
typedef struct pt_update_info PT_UPDATE_INFO;
typedef struct pt_update_stats_info PT_UPDATE_STATS_INFO;
typedef struct pt_get_stats_info PT_GET_STATS_INFO;
typedef struct pt_set_session_variable_info PT_SET_SESSION_VARIABLE_INFO;
#if defined (ENABLE_UNUSED_FUNCTION)
typedef struct pt_use_info PT_USE_INFO;
#endif
typedef struct pt_monetary_value PT_MONETARY;
typedef struct pt_enum_element_value PT_ENUM_ELEMENT;
typedef union pt_data_value PT_DATA_VALUE;
typedef struct pt_value_info PT_VALUE_INFO;
typedef struct PT_ZZ_ERROR_MSG_INFO PT_ZZ_ERROR_MSG_INFO;
typedef struct pt_foreign_key_info PT_FOREIGN_KEY_INFO;
typedef struct pt_constraint_info PT_CONSTRAINT_INFO;
typedef struct pt_pointer_info PT_POINTER_INFO;
typedef struct pt_stored_proc_info PT_STORED_PROC_INFO;
typedef struct pt_prepare_info PT_PREPARE_INFO;
typedef struct pt_execute_info PT_EXECUTE_INFO;
typedef struct pt_stored_proc_param_info PT_STORED_PROC_PARAM_INFO;
typedef struct pt_stored_proc_body_info PT_SP_BODY_INFO;
typedef struct pt_truncate_info PT_TRUNCATE_INFO;
typedef struct pt_do_info PT_DO_INFO;
typedef union pt_statement_info PT_STATEMENT_INFO;
typedef struct pt_node_list_info PT_NODE_LIST_INFO;
typedef struct pt_table_option_info PT_TABLE_OPTION_INFO;
typedef struct pt_check_option_info PT_CHECK_OPTION_INFO;
typedef struct pt_agg_check_info PT_AGG_CHECK_INFO;
typedef struct pt_agg_rewrite_info PT_AGG_REWRITE_INFO;
typedef struct pt_agg_find_info PT_AGG_FIND_INFO;
typedef struct pt_agg_name_info PT_AGG_NAME_INFO;
typedef struct pt_filter_index_info PT_FILTER_INDEX_INFO;
typedef struct pt_non_groupby_col_info PT_NON_GROUPBY_COL_INFO;
typedef struct pt_host_vars PT_HOST_VARS;
typedef struct cursor_id PT_CURSOR_ID;
typedef struct qfile_list_id PT_LIST_ID;
typedef struct nested_view_version_info NESTED_VIEW_VERSION_INFO;
typedef struct view_cache_info VIEW_CACHE_INFO;
typedef struct semantic_chk_info SEMANTIC_CHK_INFO;
typedef struct parser_hint PT_HINT;
typedef struct pt_set_names_info PT_SET_NAMES_INFO;
typedef struct pt_trace_info PT_TRACE_INFO;
typedef struct pt_tuple_value_info PT_TUPLE_VALUE_INFO;
typedef struct pt_with_clause_info PT_WITH_CLAUSE_INFO;
typedef struct pt_insert_value_info PT_INSERT_VALUE_INFO;
typedef struct pt_set_timezone_info PT_SET_TIMEZONE_INFO;
typedef struct pt_flat_spec_info PT_FLAT_SPEC_INFO;
typedef struct pt_json_table_info PT_JSON_TABLE_INFO;
typedef struct pt_json_table_node_info PT_JSON_TABLE_NODE_INFO;
typedef struct pt_json_table_column_info PT_JSON_TABLE_COLUMN_INFO;
typedef struct pt_synonym_info PT_SYNONYM_INFO;
typedef PT_NODE *(*PT_NODE_WALK_FUNCTION) (PARSER_CONTEXT * p, PT_NODE * tree, void *arg, int *continue_walk);
typedef PARSER_VARCHAR *(*PT_PRINT_VALUE_FUNC) (PARSER_CONTEXT * parser, const PT_NODE * val);
/* This is for loose reference to init node function vector */
typedef void (*PARSER_GENERIC_VOID_FUNCTION) ();
typedef struct must_be_filtering_info MUST_BE_FILTERING_INFO;
struct must_be_filtering_info
{
UINTPTR first_spec_id;
bool must_be_filtering;
bool has_second_spec_id;
};
struct semantic_chk_info
{
PT_NODE *top_node; /* top_node_arg */
PT_NODE *Oracle_outerjoin_spec; /* Oracle style outer join check */
int Oracle_outerjoin_attr_num; /* Oracle style outer join check */
int Oracle_outerjoin_subq_num; /* Oracle style outer join check */
int Oracle_outerjoin_path_num; /* Oracle style outer join check */
bool donot_fold; /* false - off, true - on */
bool system_class; /* system class(es) is(are) referenced */
bool has_dblink;
};
struct nested_view_version_info
{
DB_OBJECT *class_object; /* the nested view's class object */
unsigned int virtual_cache_local_schema_id;
unsigned int virtual_cache_global_schema_id;
unsigned int virtual_cache_snapshot_version;
NESTED_VIEW_VERSION_INFO *next;
};
struct view_cache_info
{
PT_NODE *attrs;
PT_NODE *vquery_for_query;
PT_NODE *vquery_for_query_in_gdb;
PT_NODE *vquery_for_update;
PT_NODE *vquery_for_update_in_gdb;
PT_NODE *vquery_for_partial_update;
PT_NODE *inverted_vquery_for_update;
PT_NODE *inverted_vquery_for_update_in_gdb;
char **expressions;
int number_of_attrs;
DB_AUTH authorization;
NESTED_VIEW_VERSION_INFO *nested_views;
bool has_reuse_oid_table;
};
struct parser_hint
{
const char *tokens;
PT_NODE *arg_list;
PT_HINT_ENUM hint;
int length; /* strlen(tokens) */
bool is_hit;
};
struct pt_alter_info
{
PT_NODE *entity_name; /* PT_NAME */
PT_ALTER_CODE code; /* value will be PT_ADD_ATTR, PT_DROP_ATTR ... */
PT_MISC_TYPE entity_type; /* PT_VCLASS, ... */
struct
{
PT_NODE *sup_class_list; /* PT_NAME */
PT_NODE *resolution_list; /* PT_RESOLUTION */
} super;
union
{
struct
{
PT_NODE *query; /* PT_SELECT */
PT_NODE *query_no_list; /* PT_VALUE(list) */
PT_NODE *attr_def_list; /* to be filled in semantic check */
PT_NODE *view_comment; /* PT_VALUE */
} query;
struct
{
PT_NODE *attr_def_list; /* PT_ATTR_DEF */
PT_NODE *attr_old_name; /* PT_NAME used for CHANGE <old> <new> */
PT_NODE *attr_mthd_name_list; /* PT_NAME(list) */
PT_NODE *mthd_def_list; /* PT_METHOD_DEF */
PT_NODE *mthd_file_list; /* PT_FILE_PATH */
PT_NODE *mthd_name_list; /* PT_NAME(list) */
PT_MISC_TYPE attr_type; /* PT_NORMAL_ATTR, PT_CLASS_ATTR */
} attr_mthd;
struct
{
PT_NODE *attr_name_list; /* PT_NAME(list) */
PT_NODE *data_default_list; /* PT_DATA_DEFAULT(list) */
} ch_attr_def;
struct
{
PT_MISC_TYPE element_type; /* PT_ATTRIBUTE, PT_METHOD */
PT_MISC_TYPE meta; /* PT_META, PT_NORMAL */
PT_NODE *old_name;
PT_NODE *new_name;
PT_NODE *mthd_name;
PT_MISC_TYPE mthd_type; /* PT_META, PT_NORMAL */
} rename;
struct
{
PT_NODE *info; /* PT_PARTITION_INFO */
PT_NODE *name_list; /* PT_NAME(list) */
PT_NODE *parts; /* PT_PARTS_INFO(list) */
PT_NODE *size; /* PT_VALUE */
} partition;
struct
{
int charset; /* charset for PT_CHANGE_COLLATION If the alter statement contains a valid charset
* spec, it is saved into the corresponding member of the struct(charset) Otherwise,
* charset = -1. */
int collation_id; /* collation for PT_CHANGE_COLLATION If the alter statement contains a valid collation
* spec, it is saved into the corresponding member of the struct, e.g. collation_id.
* Otherwise, collation_id = -1. */
} collation;
struct
{
bool reverse;
bool unique;
} index;
struct
{
PT_NODE *start_value;
} auto_increment;
struct
{
PT_NODE *user_name; /* user name for PT_CHANGE_OWNER */
} user;
struct
{
PT_NODE *tbl_comment; /* PT_VALUE, comment for table/view */
} comment;
} alter_clause;
PT_NODE *constraint_list; /* constraints from ADD and CHANGE clauses */
PT_NODE *create_index; /* PT_CREATE_INDEX from ALTER ADD INDEX */
PT_NODE *internal_stmts; /* internally created statements to handle TEXT */
PT_HINT_ENUM hint;
};
/* ALTER USER INFO */
struct pt_alter_user_info
{
PT_NODE *user_name; /* PT_NAME */
PT_NODE *password; /* PT_VALUE (string) */
PT_NODE *comment; /* PT_VALUE */
PT_ALTER_CODE code; /* PT_ADD_MEMBERS, PT_DROP_MEMBERS */
PT_NODE *members; /* PT_NAME list */
};
/* Info for ALTER_TRIGGER */
struct pt_alter_trigger_info
{
PT_NODE *trigger_spec_list; /* PT_TRIGGER_SPEC_LIST */
PT_NODE *trigger_priority; /* PT_VALUE */
PT_NODE *trigger_owner; /* PT_NAME */
PT_MISC_TYPE trigger_status; /* ACTIVE, INACTIVE */
PT_NODE *comment; /* PT_VALUE */
};
/* Info for ATTACH & PREPARE TO COMMIT statements */
struct pt_attach_info
{
int trans_id; /* transaction id */
};
/* Info for ATTR_DEF */
struct pt_attr_def_info
{
PT_NODE *attr_name; /* PT_NAME */
PT_NODE *data_default; /* PT_DATA_DEFAULT */
DB_DEFAULT_EXPR_TYPE on_update;
PT_NODE *auto_increment; /* PT_AUTO_INCREMENT */
PT_NODE *ordering_info; /* PT_ATTR_ORDERING */
PT_NODE *comment; /* PT_VALUE */
PT_MISC_TYPE attr_type; /* PT_NORMAL or PT_META */
int size_constraint; /* max length of STRING */
short constrain_not_null;
};
/* Info for ALTER TABLE ADD COLUMN [FIRST | AFTER column_name ] */
struct pt_attr_ordering_info
{
PT_NODE *after; /* PT_NAME */
bool first;
};
/* Info for AUTH_CMD */
struct pt_auth_cmd_info
{
PT_NODE *attr_mthd_list; /* PT_NAME (list of attr names) */
PT_PRIV_TYPE auth_cmd; /* enum PT_SELECT_PRIV, PT_ALL_PRIV,... */
};
/* Info COMMIT WORK */
struct pt_commit_work_info
{
unsigned retain_lock:1; /* 0 = false, 1 = true */
};
typedef enum
{
PT_CREATE_SELECT_NO_ACTION,
PT_CREATE_SELECT_REPLACE,
PT_CREATE_SELECT_IGNORE
} PT_CREATE_SELECT_ACTION;
/* Info for a CREATE ENTITY node */
struct pt_create_entity_info
{
PT_MISC_TYPE entity_type; /* enum PT_CLASS, PT_VCLASS .. */
PT_MISC_TYPE with_check_option; /* 0, PT_LOCAL, or PT_CASCADED */
PT_NODE *entity_name; /* PT_NAME */
PT_NODE *supclass_list; /* PT_NAME (list) */
PT_NODE *class_attr_def_list; /* PT_ATTR_DEF (list) */
PT_NODE *attr_def_list; /* PT_ATTR_DEF (list) */
PT_NODE *table_option_list; /* PT_TABLE_OPTION (list) */
PT_NODE *method_def_list; /* PT_ATTR_DEF (list) */
PT_NODE *method_file_list; /* PT_FILE_PATH (list) */
PT_NODE *resolution_list; /* PT_RESOLUTION */
PT_NODE *as_query_list; /* PT_SELECT (list) */
PT_NODE *object_id_list; /* PT_NAME list */
PT_NODE *update; /* PT_EXPR (list ) */
PT_NODE *constraint_list; /* PT_CONSTRAINT (list) */
PT_NODE *create_index; /* PT_CREATE_INDEX */
PT_NODE *partition_info; /* PT_PARTITION_INFO */
PT_NODE *internal_stmts; /* internally created statements to handle TEXT */
PT_NODE *create_like; /* PT_NAME */
PT_NODE *create_select; /* PT_SELECT or another type of select_expression */
PT_NODE *vclass_comment; /* PT_VALUE, comment of vclass, see also: table_option_list for comment of class */
PT_CREATE_SELECT_ACTION create_select_action; /* nothing | REPLACE | IGNORE for CREATE SELECT */
unsigned or_replace:1; /* OR REPLACE clause for create view */
unsigned if_not_exists:1; /* IF NOT EXISTS clause for create table | class */
};
/* CREATE/DROP INDEX INFO */
struct pt_index_info
{
PT_NODE *indexed_class; /* PT_SPEC */
PT_NODE *column_names; /* PT_SORT_SPEC (list) */
PT_NODE *index_name; /* PT_NAME */
#if defined (ENABLE_RENAME_CONSTRAINT)
PT_NODE *new_name; /* PT_NAME */
#endif
PT_NODE *prefix_length; /* PT_NAME */
PT_NODE *where; /* PT_EXPR */
PT_NODE *function_expr; /* PT_EXPR - expression to be used in a function index */
PT_NODE *comment; /* PT_VALUE */
PT_ALTER_CODE code;
int func_pos; /* the position of the expression in the function index's column list */
int func_no_args; /* number of arguments in the function index expression
* Appears only in function index expressions, excluding constants. */
bool reverse; /* REVERSE */
bool unique; /* UNIQUE specified? */
SM_INDEX_STATUS index_status; /* Index status : NORMAL / ONLINE / INVISIBLE */
int ib_threads;
short deduplicate_level; /* -1: Not set yet, 0 : Not Use, others : mod by pow(2,deduplicate_level), refer to DEDUPLICATE_KEY_LEVEL_??? */
};
/* CREATE USER INFO */
struct pt_create_user_info
{
PT_NODE *user_name; /* PT_NAME */
PT_NODE *password; /* PT_VALUE (string) */
PT_NODE *groups; /* PT_NAME list */
PT_NODE *members; /* PT_NAME list */
PT_NODE *comment; /* PT_VALUE */
};
/* CREATE TRIGGER INFO */
struct pt_create_trigger_info
{
PT_NODE *trigger_name; /* PT_NAME */
PT_NODE *trigger_priority; /* PT_VALUE */
PT_MISC_TYPE trigger_status; /* ACTIVE, INACTIVE */
PT_MISC_TYPE condition_time; /* BEFORE, AFTER, DEFERRED */
PT_NODE *trigger_event; /* PT_EVENT_SPEC */
PT_NODE *trigger_reference; /* PT_EVENT_OBJECT (list) */
PT_NODE *trigger_condition; /* PT_EXPR or PT_METHOD_CALL */
PT_NODE *trigger_action; /* PT_TRIGGER_ACTION */
PT_MISC_TYPE action_time; /* BEFORE, AFTER, DEFERRED */
PT_NODE *comment; /* PT_VALUE */
};
/* CTE(Common Table Expression) INFO */
struct pt_cte_info
{
PT_NODE *name; /* PT_NAME */
PT_NODE *as_attr_list; /* PT_NAME */
PT_NODE *non_recursive_part; /* the non-recursive subquery */
PT_NODE *recursive_part; /* a recursive subquery */
PT_MISC_TYPE only_all; /* Type of UNION between non-recursive and recursive parts */
void *xasl; /* xasl proc pointer */
int referenced_count; /* The number of times the CTE is referenced */
bool is_materialized;
};
/* CREATE SERIAL INFO */
struct pt_serial_info
{
PT_NODE *serial_name; /* PT_NAME */
PT_NODE *start_val; /* PT_VALUE */
PT_NODE *increment_val; /* PT_VALUE */
PT_NODE *max_val; /* PT_VALUE */
PT_NODE *min_val; /* PT_VALUE */
PT_NODE *cached_num_val; /* PT_VALUE */
PT_NODE *owner_name; /* PT_NAME */
PT_NODE *comment; /* PT_VALUE */
PT_ALTER_CODE code; /* PT_SERIAL_OPTION, PT_CHANGE_OWNER */
int cyclic;
int no_max;
int no_min;
int no_cyclic;
int no_cache;
unsigned if_exists:1; /* IF EXISTS clause for drop serial */
};
/* Info for DATA_DEFAULT */
struct pt_data_default_info
{
PT_NODE *default_value; /* PT_VALUE (list) */
PT_MISC_TYPE shared; /* will PT_SHARED or PT_DEFAULT */
DB_DEFAULT_EXPR_TYPE default_expr_type; /* if it is a pseudocolumn, do not evaluate expr */
};
/* Info for the AUTO_INCREMENT node */
struct pt_auto_increment_info
{
PT_NODE *start_val; /* PT_VALUE */
PT_NODE *increment_val; /* PT_VALUE */
};
/* Info for the PARTITION node */
struct pt_partition_info
{
PT_NODE *expr;
PT_NODE *keycol;
PT_NODE *hashsize;
PT_NODE *parts; /* PT_PARTS_INFO list */
PT_PARTITION_TYPE type;
};
struct pt_parts_info
{
PT_NODE *name; /* PT_NAME */
PT_NODE *values; /* PT_VALUE (or list) */
PT_PARTITION_TYPE type;
PT_NODE *comment; /* PT_VALUE */
};
#define PARTITIONED_SUB_CLASS_TAG "__p__"
/* Info for DATA_TYPE node */
struct pt_data_type_info
{
PT_NODE *entity; /* class PT_NAME list for PT_TYPE_OBJECT */
PT_NODE *enumeration; /* values list for PT_TYPE_ENUMERATION */
DB_OBJECT *virt_object; /* virt class object if a vclass */
PT_NODE *table_column; /* for type specification of the form <table>.<column>%TYPE */
PT_TYPE_ENUM virt_type_enum; /* type enumeration tage PT_TYPE_??? */
int precision; /* for float and int, length of char */
int dec_precision; /* decimal precision for float */
int units; /* for money (or string's codeset) */
int collation_id; /* collation identifier (strings) */
/* how the collation should be taken into account */
TP_DOMAIN_COLL_ACTION collation_flag;
bool has_coll_spec; /* this is used only when defining collatable types: true if collation was explicitly
* set, false otherwise (collation defaulted to that of the system) */
bool has_cs_spec; /* this is used only when defining collatable types: true if charset was explicitly
* set, false otherwise (charset defaulted to that of the system) */
PT_MISC_TYPE inout; /* input or output method parameter */
PARSER_VARCHAR *json_schema;
};
/* DELETE */
struct pt_delete_info
{
PT_NODE *target_classes; /* PT_NAME */
PT_NODE *spec; /* PT_SPEC (list) */
PT_NODE *class_specs; /* PT_SPEC list */
PT_NODE *search_cond; /* PT_EXPR */
PT_NODE *using_index; /* PT_NAME (list) */
PT_NODE *cursor_name; /* PT_NAME */
PT_NODE *internal_stmts; /* internally created statements to handle TEXT */
PT_NODE *waitsecs_hint; /* lock timeout in seconds */
PT_NODE *leading_hint; /* LEADING_HINT hint's arguments (PT_NAME list) */
PT_NODE *use_nl_hint; /* USE_NL hint's arguments (PT_NAME list) */
PT_NODE *use_idx_hint; /* USE_IDX hint's arguments (PT_NAME list) */
PT_NODE *use_merge_hint; /* USE_MERGE hint's arguments (PT_NAME list) */
PT_NODE *no_use_hash_hint; /* NO_USE_HASH hint's arguments (PT_NAME list) */
PT_NODE *use_hash_hint; /* USE_HASH hint's arguments (PT_NAME list) */
PT_NODE *limit; /* PT_VALUE limit clause parameter */
PT_NODE *del_stmt_list; /* list of DELETE statements after split */
PT_HINT_ENUM hint; /* hint flag */
PT_NODE *with; /* PT_WITH_CLAUSE */
int num_parallel_threads; /* number of parallel threads */
unsigned has_trigger:1; /* whether it has triggers */
unsigned server_delete:1; /* whether it can be server-side deletion */
unsigned rewrite_limit:1; /* need to rewrite the limit clause */
unsigned execute_with_commit_allowed:1; /* true, if execute with commit allowed. */
};
/* DOT_INFO*/
struct pt_dot_info
{
PT_NODE *arg1; /* PT_EXPR etc. first argument */
PT_NODE *arg2; /* PT_EXPR etc. possible second argument */
PT_NODE *selector; /* only set if selector used A[SELECTOR].B */
short tag_click_counter; /* 0: normal name, 1: click counter name */
int coll_modifier; /* collation modifier = collation + 1 */
};
/* DROP ENTITY
as in DROP VCLASS X,Y,Z; (different from ALTER .... or DROP VIEW )
*/
struct pt_drop_info
{
PT_NODE *spec_list; /* PT_SPEC (list) */
PT_NODE *internal_stmts; /* internally created statements to handle TEXT */
PT_MISC_TYPE entity_type; /* PT_VCLASS, PT_CLASS */
bool if_exists; /* IF EXISTS clause for DROP TABLE */
bool is_cascade_constraints; /* whether to drop cascade FK key */
};
/* DROP USER INFO */
struct pt_drop_user_info
{
PT_NODE *user_name; /* PT_NAME */
};
/* DROP TRIGGER */
struct pt_drop_trigger_info
{
PT_NODE *trigger_spec_list; /* PT_TRIGGER_SPEC_LIST */
};
/* DROP VARIABLE */
struct pt_drop_variable_info
{
PT_NODE *var_names; /* PT_NAME (list) */
};
struct pt_drop_session_var_info
{
PT_NODE *variables; /* PT_VALUE list */
};
/* Info for a ENTITY spec and spec_list */
struct pt_spec_info
{
PT_NODE *entity_name; /* PT_NAME */
PT_NODE *remote_server_name; /* PT_NAME or PT_DBLINK_INFO */
PT_NODE *cte_name; /* PT_NAME */
PT_NODE *cte_pointer; /* PT_POINTER - points to the cte_definition */
PT_NODE *except_list; /* PT_SPEC */
PT_NODE *derived_table; /* a subquery */
PT_NODE *range_var; /* PT_NAME */
PT_NODE *as_attr_list; /* PT_NAME */
PT_NODE *referenced_attrs; /* PT_NAME list of referenced attrs */
PT_NODE *path_entities; /* PT_SPECs implied by path expr's */
PT_NODE *path_conjuncts; /* PT_EXPR boolean nodes */
PT_NODE *flat_entity_list; /* PT_NAME (list) resolved class's */
PT_NODE *method_list; /* PT_METHOD_CALL list with this entity as the target */
PT_NODE *partition; /* PT_NAME of the specified partition */
PT_NODE *json_table; /* JSON TABLE definition tree */
UINTPTR id; /* entity spec unique id # */
PT_MISC_TYPE only_all; /* PT_ONLY or PT_ALL */
PT_MISC_TYPE meta_class; /* enum 0 or PT_META */
PT_MISC_TYPE derived_table_type; /* PT_IS_SUBQUERY, PT_IS_SET_EXPR, or PT_IS_CSELECT, PT_IS_SHOWSTMT */
PT_MISC_TYPE flavor; /* enum 0 or PT_METHOD_ENTITY */
PT_NODE *on_cond;
PT_NODE *using_cond; /* -- does not support named columns join */
PT_JOIN_TYPE join_type;
short location; /* n-th position in FROM (start from 0); init val = -1 */
bool natural; /* -- does not support natural join */
DB_AUTH auth_bypass_mask; /* flag to bypass normal authorization : used only by SHOW statements currently */
PT_SPEC_FLAG flag; /* flag wich marks this spec for DELETE or UPDATE operations */
int num_parallel_threads; /* number of parallel threads for this spec */
};
/* Info for an EVALUATE object */
struct pt_evaluate_info
{
PT_NODE *expression; /* PT_EXPR or PT_METHOD_CALL */
PT_NODE *into_var; /* PT_VALUE */
};
/* Info for an EVENT object */
struct pt_event_object_info
{
PT_NODE *event_object; /* PT_NAME: current, new, old */
PT_NODE *correlation_name; /* PT_NAME */
};
/* Info for an EVENT spec */
struct pt_event_spec_info
{
PT_NODE *event_target; /* PT_EVENT_TARGET */
PT_EVENT_TYPE event_type;
};
/* Info for an EVENT target */
struct pt_event_target_info
{
PT_NODE *class_name; /* PT_NAME */
PT_NODE *attribute; /* PT_NAME or NULL */
};
/* EXECUTE TRIGGER */
struct pt_execute_trigger_info
{
PT_NODE *trigger_spec_list; /* PT_TRIGGER_SPEC_LIST */
};
/* Info for Expressions
This includes binary and unary operations + * - etc
*/
struct pt_expr_info
{
PT_NODE *arg1; /* PT_EXPR etc. first argument */
PT_NODE *arg2; /* PT_EXPR etc. possible second argument */
PT_NODE *value; /* only set if we evaluate it */
PT_OP_TYPE op; /* binary or unary op code */
int paren_type; /* 0 - none, else - () */
PT_NODE *arg3; /* possible third argument (like, between, or case) */
PT_NODE *cast_type; /* PT_DATA_TYPE, resultant cast domain */
PT_MISC_TYPE qualifier; /* trim qualifier (LEADING, TRAILING, BOTH), datetime extract field specifier (YEAR,
* ..., SECOND), or case expr type specifier (NULLIF, COALESCE, SIMPLE_CASE,
* SEARCHED_CASE) */
#define PT_EXPR_INFO_CNF_DONE 1 /* CNF conversion has done? */
#define PT_EXPR_INFO_EMPTY_RANGE 2 /* empty RANGE spec? */
#define PT_EXPR_INFO_INSTNUM_C 4 /* compatible with inst_num() */
#define PT_EXPR_INFO_INSTNUM_NC 8 /* not compatible with inst_num() */
#define PT_EXPR_INFO_GROUPBYNUM_C 16 /* compatible with groupby_num() */
#define PT_EXPR_INFO_GROUPBYNUM_NC 32 /* not compatible with groupby_num() */
#define PT_EXPR_INFO_ORDERBYNUM_C \
PT_EXPR_INFO_INSTNUM_C /* compatible with orderby_num() */
#define PT_EXPR_INFO_ORDERBYNUM_NC \
PT_EXPR_INFO_INSTNUM_NC /* not compatible with orderby_num() */
#define PT_EXPR_INFO_TRANSITIVE 64 /* always true transitive join term ? */
#define PT_EXPR_INFO_LEFT_OUTER 128 /* Oracle's left outer join operator */
#define PT_EXPR_INFO_RIGHT_OUTER 256 /* Oracle's right outer join operator */
#define PT_EXPR_INFO_COPYPUSH 512 /* term which is copy-pushed into the derived subquery ? is removed at the last
* rewrite stage of query optimizer */
#if 1 /* unused anymore - DO NOT DELETE ME */
#define PT_EXPR_INFO_FULL_RANGE 1024 /* non-null full RANGE term ? */
#endif
#define PT_EXPR_INFO_CAST_NOFAIL 2048 /* flag for non failing cast operation; at runtime will return null DB_VALUE
* instead of failing */
#define PT_EXPR_INFO_CAST_SHOULD_FOLD 4096 /* flag which controls if a cast expr should be folded */
#define PT_EXPR_INFO_FUNCTION_INDEX 8192 /* function index expression flag */
#define PT_EXPR_INFO_CAST_COLL_MODIFIER 16384 /* CAST is for COLLATION modifier */
#define PT_EXPR_INFO_GROUPBYNUM_LIMIT 32768 /* flag that marks if the expression resulted from a GROUP BY ... LIMIT
* statement */
#define PT_EXPR_INFO_DO_NOT_AUTOPARAM 65536 /* don't auto parameterize expr at qo_auto_parameterize() */
#define PT_EXPR_INFO_CAST_WRAP 131072 /* 0x20000, CAST is wrapped by compiling */
#define PT_EXPR_INFO_ROWNUM_ONLY 262144 /* 0x40000, rownum only predicate */
#define PT_EXPR_INFO_SP_NUMERIC 524288 /* 0x80000, CAST as NUMERIC for SP */
#define PT_EXPR_INFO_REMOVABLE 1048576 /* 0x100000, expression is removable */
int flag; /* flags */
#define PT_EXPR_INFO_IS_FLAGED(e, f) ((e)->info.expr.flag & (int) (f))
#define PT_EXPR_INFO_SET_FLAG(e, f) (e)->info.expr.flag |= (int) (f)
#define PT_EXPR_INFO_CLEAR_FLAG(e, f) (e)->info.expr.flag &= (int) ~(f)
short continued_case; /* 0 - false, 1 - true */
short location; /* 0 : WHERE; n : join condition of n-th FROM */
bool is_order_dependent; /* true if expression is order dependent */
PT_TYPE_ENUM recursive_type; /* common type for recursive expression arguments (like PT_GREATEST, PT_LEAST,...) */
int coll_modifier; /* collation modifier = collation + 1 */
int pred_order; /* for view-merge or predicate-push. pred is ordered by pred_order in qo_discover_edges */
};
/* FILE PATH INFO */
struct pt_file_path_info
{
PT_NODE *string; /* PT_VALUE: a C or ANSI string */
};
/* FUNCTIONS ( COUNT, AVG, ....) */
struct pt_function_info
{
PT_NODE *arg_list; /* PT_EXPR(list) */
FUNC_CODE function_type; /* PT_COUNT, PT_AVG, ... */
PT_MISC_TYPE all_or_distinct; /* will be PT_ALL or PT_DISTINCT */
const char *generic_name; /* only for type PT_GENERIC */
char hidden_column; /* used for updates and deletes for the class OID column */
PT_NODE *order_by; /* ordering PT_SORT_SPEC for GROUP_CONCAT */
PT_NODE *percentile; /* percentile for PERCENTILE_CONT, PERCENTILE_DISC */
bool is_order_dependent; /* true if function is order dependent */
bool is_type_checked; /* true if type is already checked, false otherwise... is this safe? */
int coll_modifier; /* collation modifier = collation + 1 */
struct
{
PT_NODE *partition_by; /* partition PT_SORT_SPEC list */
PT_NODE *order_by; /* ordering PT_SORT_SPEC list */
PT_NODE *default_value; /* LEAD/LAG function default value */
PT_NODE *offset; /* LEAD/LAG/NTH_VALUE function offset */
PT_NODE *expanded_list; /* reserved list when expand partition_by/order_by */
bool adjusted; /* whether the partition_by/order_by be adjusted and expanded */
bool from_last; /* determines whether the calculation begins at the last or first row */
bool ignore_nulls; /* determines whether the calculation eliminate or includes null values */
bool is_analytic; /* is analytic clause */
} analytic;
};
/* Info for Get Optimization Level statement */
struct pt_get_opt_lvl_info
{
PT_NODE *args;
PT_NODE *into_var; /* PT_VALUE */
PT_MISC_TYPE option; /* PT_OPT_LVL, PT_OPT_COST */
};
/* Info for Get Trigger statement */
struct pt_get_trigger_info
{
PT_NODE *into_var; /* PT_VALUE */
PT_MISC_TYPE option; /* PT_TRIGGER_DEPTH, PT_TRIGGER_TRACE */
};
/* Info for Get Transaction statement */
struct pt_get_xaction_info
{
PT_NODE *into_var; /* PT_VALUE */
PT_MISC_TYPE option; /* PT_ISOLATION_LEVEL or PT_LOCK_TIMEOUT */
};
/* GRANT INFO */
struct pt_grant_info
{
PT_NODE *auth_cmd_list; /* PT_AUTH_CMD(list) */
PT_NODE *user_list; /* PT_NAME */
PT_NODE *spec_list; /* PT_SPEC (class) or PT_NAME (procedure) */
PT_MISC_TYPE grant_option; /* = PT_GRANT_OPTION or PT_NO_GRANT_OPTION */
};
/* Info for Host_Var */
struct pt_host_var_info
{
const char *str; /* ??? */
PT_MISC_TYPE var_type; /* PT_HOST_IN, PT_HOST_OUT, */
int index; /* for PT_HOST_VAR ordering */
const char *label;
/* for processing subquery's result cache */
int saved; /* for saving the main query's host_var indexes */
PT_NODE *next; /* for linking to same host_var indexes */
};
/* Info for lists of PT_NODE */
struct pt_node_list_info
{
PT_MISC_TYPE list_type; /* e.g. PT_IS_VALUE */
PT_NODE *list; /* the list of nodes */
};
/* Info for Insert */
struct pt_insert_info
{
PT_NODE *spec; /* PT_SPEC */
PT_NODE *class_specs; /* PT_SPEC list */
PT_NODE *attr_list; /* PT_NAME */
PT_NODE *value_clauses; /* PT_NODE_LIST(list) or PT_NODE_LIST(PT_SELECT) */
PT_NODE *into_var; /* PT_VALUE */
PT_MISC_TYPE is_subinsert; /* 0 or PT_IS_SUBINSERT(for printing) */
PT_NODE *where; /* for view with check option checking */
PT_NODE *internal_stmts; /* internally created statements to handle TEXT */
PT_NODE *waitsecs_hint; /* lock timeout in seconds */
PT_HINT_ENUM hint; /* hint flag */
PT_NODE *odku_assignments; /* ON DUPLICATE KEY UPDATE assignments */
bool do_replace; /* REPLACE statement was given */
PT_NODE *insert_mode; /* insert execution mode */
PT_NODE *non_null_attrs; /* attributes with not null constraint */
PT_NODE *odku_non_null_attrs; /* attributes with not null constraint in odku assignments */
int has_uniques; /* class has unique constraints */
SERVER_INSERT_ALLOWED server_allowed; /* is insert allowed on server */
unsigned execute_with_commit_allowed:1; /* true, if execute with commit allowed. */
};
/* Info for Transaction Isolation Level */
struct pt_isolation_lvl_info
{
PT_MISC_TYPE schema;
PT_MISC_TYPE instances;
PT_NODE *level; /* PT_VALUE */
unsigned async_ws:1; /* 0 = false, 1 = true */
};
/* Info for Method Call */
struct pt_method_call_info
{
PT_NODE *method_name; /* PT_NAME or PT_METHOD_DEF */
PT_NODE *arg_list; /* PT_EXPR (list ) */
PT_NODE *on_call_target; /* PT_NAME */
PT_NODE *to_return_var; /* PT_NAME */
PT_MISC_TYPE call_or_expr; /* PT_IS_CALL_STMT or PT_IS_MTHD_EXPR */
PT_MISC_TYPE method_type; /* PT_IS_CLASS_MTHD, PT_IS_INST_MTHD, PT_SP_PROCEDURE, PT_SP_FUNCTION */
char *auth_name; /* owner or current user name */
PT_MISC_TYPE auth_id; /* PT_AUTHID_OWNER, PT_AUTHID_CALLER */
UINTPTR method_id; /* unique identifier so when copying we know if two methods are copies of the same
* original method call. */
};
/* Info for METHOD DEFs */
struct pt_method_def_info
{
PT_NODE *method_name; /* PT_NAME */
PT_NODE *method_args_list; /* PT_DATA_TYPE (list) */
PT_NODE *function_name; /* PT_VALUE (string) */
PT_MISC_TYPE mthd_type; /* PT_NORMAL or ... */
};
/*
* Reserved names section
*/
/* Enumeration of reserved names categories */
typedef enum
{
RESERVED_NAME_INVALID = -1,
RESERVED_NAME_RECORD_INFO = 0,
RESERVED_NAME_PAGE_INFO,
RESERVED_NAME_KEY_INFO,
RESERVED_NAME_BTREE_NODE_INFO
} PT_RESERVED_NAME_TYPE;
/* Enumeration of reserved name ids */
typedef enum
{
/* Reserved record info names */
RESERVED_T_PAGEID = 0,
RESERVED_T_SLOTID,
RESERVED_T_VOLUMEID,
RESERVED_T_OFFSET,
RESERVED_T_LENGTH,
RESERVED_T_REC_TYPE,
RESERVED_T_REPRID,
RESERVED_T_CHN,
/* leave MVCC attributes at the end of record information */
RESERVED_T_MVCC_INSID,
RESERVED_T_MVCC_DELID,
RESERVED_T_MVCC_FLAGS,
RESERVED_T_MVCC_PREV_VERSION_LSA,
/* Reserved page info names */
RESERVED_P_CLASS_OID,
RESERVED_P_CUR_VOLUMEID,
RESERVED_P_CUR_PAGEID,
RESERVED_P_PREV_PAGEID,
RESERVED_P_NEXT_PAGEID,
RESERVED_P_NUM_SLOTS,
RESERVED_P_NUM_RECORDS,
RESERVED_P_ANCHOR_TYPE,
RESERVED_P_ALIGNMENT,
RESERVED_P_TOTAL_FREE,
RESERVED_P_CONT_FREE,
RESERVED_P_OFFSET_TO_FREE_AREA,
RESERVED_P_IS_SAVING,
RESERVED_P_UPDATE_BEST,
/* Reserved key info names */
RESERVED_KEY_VOLUMEID,
RESERVED_KEY_PAGEID,
RESERVED_KEY_SLOTID,
RESERVED_KEY_KEY,
RESERVED_KEY_OID_COUNT,
RESERVED_KEY_FIRST_OID,
RESERVED_KEY_OVERFLOW_KEY,
RESERVED_KEY_OVERFLOW_OIDS,
/* Reserved b-tree node info names */
RESERVED_BT_NODE_VOLUMEID,
RESERVED_BT_NODE_PAGEID,
RESERVED_BT_NODE_TYPE,
RESERVED_BT_NODE_KEY_COUNT,
RESERVED_BT_NODE_FIRST_KEY,
RESERVED_BT_NODE_LAST_KEY,
/* leave this last to know how many reserved names are in pt_Reserved_name_table */
RESERVED_ATTR_COUNT,
/* make sure you update these values when adding or removing items */
RESERVED_FIRST_RECORD_INFO = RESERVED_T_PAGEID,
RESERVED_FIRST_MVCC_INFO = RESERVED_T_MVCC_INSID,
RESERVED_LAST_RECORD_INFO = RESERVED_T_MVCC_PREV_VERSION_LSA,
RESERVED_FIRST_PAGE_INFO = RESERVED_P_CLASS_OID,
RESERVED_LAST_PAGE_INFO = RESERVED_P_UPDATE_BEST,
RESERVED_FIRST_KEY_INFO = RESERVED_KEY_VOLUMEID,
RESERVED_LAST_KEY_INFO = RESERVED_KEY_OVERFLOW_OIDS,
RESERVED_FIRST_BT_NODE_INFO = RESERVED_BT_NODE_VOLUMEID,
RESERVED_LAST_BT_NODE_INFO = RESERVED_BT_NODE_LAST_KEY
} PT_RESERVED_NAME_ID;
/* Reserved name info */
typedef struct pt_reserved_name PT_RESERVED_NAME;
struct pt_reserved_name
{
const char *name;
PT_RESERVED_NAME_ID id;
DB_TYPE type;
};
/* Global reserved name table which stores info for each name */
extern PT_RESERVED_NAME pt_Reserved_name_table[];
/* Obtain reserved name type from id */
#define PT_GET_RESERVED_NAME_TYPE(reserved_id) \
(((reserved_id) >= RESERVED_FIRST_RECORD_INFO \
&& (reserved_id) <= RESERVED_LAST_RECORD_INFO) ? \
/* If reserved_id belongs to record info */ \
RESERVED_NAME_RECORD_INFO : \
/* else */ \
(((reserved_id) >= RESERVED_FIRST_PAGE_INFO \
&& (reserved_id) <= RESERVED_LAST_PAGE_INFO) ? \
/* If reserved_id belongs to page_info */ \
RESERVED_NAME_PAGE_INFO : \
/* else */ \
(((reserved_id) >= RESERVED_FIRST_KEY_INFO \
&& (reserved_id) <= RESERVED_LAST_KEY_INFO) ? \
/* If reserved_id belongs to key info */ \
RESERVED_NAME_KEY_INFO : \
/* else */ \
(((reserved_id) >= RESERVED_FIRST_BT_NODE_INFO \
&& (reserved_id) <= RESERVED_LAST_BT_NODE_INFO) ? \
/* If reserved_id belongs to b-tree node info */ \
RESERVED_NAME_BTREE_NODE_INFO : \
/* else must be invalid */ \
RESERVED_NAME_INVALID))))
/* Get first and last id for reserved name type */
#define PT_GET_RESERVED_NAME_FIRST_AND_LAST(type, first, last) \
switch (type) \
{ \
case RESERVED_NAME_RECORD_INFO: \
(first) = RESERVED_FIRST_RECORD_INFO; \
(last) = RESERVED_LAST_RECORD_INFO; \
break; \
case RESERVED_NAME_PAGE_INFO: \
(first) = RESERVED_FIRST_PAGE_INFO; \
(last) = RESERVED_LAST_PAGE_INFO; \
break; \
case RESERVED_NAME_KEY_INFO: \
(first) = RESERVED_FIRST_KEY_INFO; \
(last) = RESERVED_LAST_KEY_INFO; \
break; \
case RESERVED_NAME_BTREE_NODE_INFO: \
(first) = RESERVED_FIRST_BT_NODE_INFO; \
(last) = RESERVED_LAST_BT_NODE_INFO; \
break; \
default: \
assert (0); \
break; \
}
/* After resolving to a reserved name, check the binding is correct according
* to spec flag
*/
#define PT_CHECK_RESERVED_NAME_BIND(spec_, reserved_id) \
(PT_SPEC_GET_RESERVED_NAME_TYPE (spec_) \
== PT_GET_RESERVED_NAME_TYPE (reserved_id))
/* Info for Names
This includes identifiers
*/
#define NAME_FROM_PT_DOT 1
#define NAME_FROM_CLASSNAME_DOT_STAR 2 /* classname.* */
#define NAME_FROM_STAR 3 /* * */
#define NAME_IN_PATH_EXPR 4
struct pt_name_info
{
UINTPTR spec_id; /* unique identifier for entity specs */
const char *original; /* the string of the original name */
const char *resolved; /* the string of the resolved name */
DB_OBJECT *db_object; /* the object, if this is a class or instance */
int db_object_chn;
DB_OBJECT *virt_object; /* the top level view this this class is being viewed through. */
SM_PARTITION *partition; /* partition info reference */
PT_NODE *path_correlation; /* as in a.b.c [path_correlation].d.e.f */
PT_TYPE_ENUM virt_type_enum; /* type of oid's in ldb for proxies. */
PT_MISC_TYPE meta_class; /* 0 or PT_META or PT_PARAMETER or PT_CLASS */
PT_NODE *default_value; /* PT_VALUE the default value of the attribute */
PT_NODE *constant_value; /* constant value derived from qo_reduce_equality_terms () */
unsigned int custom_print;
unsigned short correlation_level; /* for correlated attributes */
char hidden_column; /* used for updates and deletes for the class OID column */
#define PT_NAME_INFO_DOT_SPEC 1 /* x, y of x.y.z */
#define PT_NAME_INFO_DOT_NAME 2 /* z of x.y.z */
#define PT_NAME_INFO_STAR 4 /* * */
#define PT_NAME_INFO_DOT_STAR 8 /* classname.* */
#define PT_NAME_INFO_CONSTANT 16
#define PT_NAME_INFO_EXTERNAL 32 /* in case of TEXT type at attr definition or attr.object at attr description */
#define PT_NAME_INFO_DESC 64 /* DESC on an index column name */
#define PT_NAME_INFO_FILL_DEFAULT 128 /* whether default_value should be filled in */
#define PT_NAME_INFO_GENERATED_OID 256 /* set when a PT_NAME node that maps to an OID is generated internally for
* statement processing and execution */
#define PT_NAME_ALLOW_REUSABLE_OID 512 /* ignore the REUSABLE_OID restrictions for this name */
#define PT_NAME_GENERATED_DERIVED_SPEC 1024 /* attribute generated from derived spec */
#define PT_NAME_FOR_UPDATE 2048 /* Table name in FOR UPDATE clause */
#define PT_NAME_DEFAULTF_ACCEPTS 4096 /* name of table/column that default function accepts: real table's, cte's */
#define PT_NAME_INFO_USER_SPECIFIED 8192 /* resolved_name is added to original_name to make user_specified_name. */
#define PT_NAME_INFO_SERVER_SPECIFIED 16384 /* server name is specified for dblink */
short flag;
#define PT_NAME_INFO_IS_FLAGED(e, f) ((e)->info.name.flag & (short) (f))
#define PT_NAME_INFO_SET_FLAG(e, f) (e)->info.name.flag |= (short) (f)
#define PT_NAME_INFO_CLEAR_FLAG(e, f) (e)->info.name.flag &= (short) ~(f)
short location; /* 0: WHERE; n: join condition of n-th FROM */
short tag_click_counter; /* 0: normal name, 1: click counter name */
PT_NODE *indx_key_limit; /* key limits for index name */
int coll_modifier; /* collation modifier = collation + 1 */
PT_RESERVED_NAME_ID reserved_id; /* used to identify reserved name */
size_t json_table_column_index; /* will be used only for json_table to gather attributes in the correct order */
};
/*
* information for arguments that has name and value
*/
struct pt_named_arg_info
{
PT_NODE *name; /* an identifier node for argument name */
PT_NODE *value; /* argument value, may be string, int or identifier */
};
enum
{
PT_IDX_HINT_FORCE = 1,
PT_IDX_HINT_USE = 0,
PT_IDX_HINT_IGNORE = -1,
PT_IDX_HINT_ALL_EXCEPT = -2,
PT_IDX_HINT_CLASS_NONE = -3,
PT_IDX_HINT_NONE = -4
};
/* PT_IDX_HINT_ORDER is used in index hint rewrite, to sort the index hints
* in the using_index clause in the order implied by this define; this is
* needed in order to avoid additional loops through the hint list */
#define PT_IDX_HINT_ORDER(hint_node) \
((hint_node->etc == (void *) PT_IDX_HINT_CLASS_NONE) ? 1 : \
(hint_node->etc == (void *) PT_IDX_HINT_IGNORE ? 2 : \
(hint_node->etc == (void *) PT_IDX_HINT_FORCE ? 3 : \
(hint_node->etc == (void *) PT_IDX_HINT_USE ? 4 : 0))))
/* REMOVE TRIGGER */
struct pt_remove_trigger_info
{
PT_NODE *trigger_spec_list; /* PT_TRIGGER_SPEC_LIST */
};
/* Info RENAME */
struct pt_rename_info
{
PT_NODE *old_name; /* PT_NAME */
PT_NODE *in_class; /* PT_NAME */
PT_NODE *new_name; /* PT_NAME */
PT_MISC_TYPE meta;
PT_MISC_TYPE attr_or_mthd;
PT_MISC_TYPE entity_type;
};
/* Info for RENAME TRIGGER */
struct pt_rename_trigger_info
{
PT_NODE *old_name; /* PT_NAME */
PT_NODE *new_name; /* PT_NAME */
};
/* Info for resolution list */
struct pt_resolution_info
{
PT_NODE *attr_mthd_name; /* PT_NAME */
PT_NODE *of_sup_class_name; /* PT_NAME */
PT_NODE *as_attr_mthd_name; /* PT_NAME */
PT_MISC_TYPE attr_type; /* enum PT_NORMAL or ... */
};
/* Info REVOKE */
struct pt_revoke_info
{
PT_NODE *auth_cmd_list;
PT_NODE *user_list;
PT_NODE *spec_list;
};
/* Info ROLLBACK */
struct pt_rollback_work_info
{
PT_NODE *save_name; /* PT_NAME */
};
/* Info for a UNION/DIFFERENCE/INTERSECTION node */
struct pt_union_info
{
PT_NODE *arg1; /* PT_SELECT_EXPR 1st argument */
PT_NODE *arg2; /* PT_SELECT_EXPR 2nd argument */
PT_NODE *select_list; /* select list of UNION query */
unsigned is_leaf_node:1;
};
/* Info for an SAVEPOINT node */
struct pt_savepoint_info
{
PT_NODE *save_name; /* PT_NAME */
};
/* Info for a SCOPE node */
struct pt_scope_info
{
PT_NODE *from; /* pt_spec (list) */
PT_NODE *stmt; /* pt_trigger_action, etc. */
};
/* Info for a SELECT node */
struct pt_select_info
{
PT_NODE *list; /* PT_EXPR PT_NAME */
PT_NODE *from; /* PT_SPEC (list) */
PT_NODE *where; /* PT_EXPR */
PT_NODE *group_by; /* PT_EXPR (list) */
PT_NODE *connect_by; /* PT_EXPR */
PT_NODE *start_with; /* PT_EXPR */
PT_NODE *after_cb_filter; /* PT_EXPR */
PT_NODE *having; /* PT_EXPR */
PT_NODE *using_index; /* PT_NAME (list) */
PT_NODE *with_increment; /* PT_NAME (list) */
PT_NODE *leading; /* PT_NAME (list) */
PT_NODE *use_nl; /* PT_NAME (list) */
PT_NODE *use_idx; /* PT_NAME (list) */
PT_NODE *index_ss; /* PT_NAME (list) */
PT_NODE *index_ls; /* PT_NAME (list) */
PT_NODE *use_merge; /* PT_NAME (list) */
PT_NODE *no_use_hash; /* PT_NAME (list) */
PT_NODE *use_hash; /* PT_NAME (list) */
PT_NODE *waitsecs_hint; /* lock timeout in seconds */
PT_NODE *jdbc_life_time; /* jdbc cache life time */
struct qo_summary *qo_summary;
PT_NODE *check_where; /* with check option predicate */
PT_NODE *for_update; /* FOR UPDATE clause tables list */
QFILE_LIST_ID *push_list; /* list file descriptor pushed to server */
PT_HINT_ENUM hint;
int flavor;
int flag; /* flags */
int num_parallel_threads;
PT_CONNECT_BY_CHECK_CYCLES check_cycles; /* CONNECT BY CHECK CYCLES */
unsigned single_table_opt:1; /* hq optimized for single table */
};
#define PT_SELECT_INFO_ANSI_JOIN 0x01 /* has ANSI join? */
#define PT_SELECT_INFO_ORACLE_OUTER 0x02 /* has Oracle's outer join operator? */
#define PT_SELECT_INFO_DUMMY 0x04 /* is dummy (i.e., 'SELECT * FROM x') ? */
#define PT_SELECT_INFO_HAS_AGG 0x08 /* has any type of aggregation? */
#define PT_SELECT_INFO_HAS_ANALYTIC 0x10 /* has analytic functions */
#define PT_SELECT_INFO_MULTI_UPDATE_AGG 0x20 /* is query for multi-table update using aggregate */
#define PT_SELECT_INFO_IDX_SCHEMA 0x40 /* is show index query */
#define PT_SELECT_INFO_COLS_SCHEMA 0x80 /* is show columns query */
#define PT_SELECT_FULL_INFO_COLS_SCHEMA 0x0100 /* is show columns query */
#define PT_SELECT_INFO_IS_MERGE_QUERY 0x0200 /* is a query of a merge stmt */
#define PT_SELECT_INFO_LIST_PUSHER 0x0400 /* dummy subquery that pushes a list file descriptor to be used at
* server as its own result */
#define PT_SELECT_INFO_NO_STRICT_OID_CHECK 0x0800 /* normally, only OIDs of updatable views are allowed in parse
* trees; however, for MERGE and UPDATE we sometimes want to
* allow OIDs of partially updatable views */
#define PT_SELECT_INFO_IS_UPD_DEL_QUERY 0x1000 /* set if select was built for an UPDATE or DELETE statement */
#define PT_SELECT_INFO_FOR_UPDATE 0x2000 /* FOR UPDATE clause is active */
#define PT_SELECT_INFO_DISABLE_LOOSE_SCAN 0x4000 /* loose scan not possible on query */
#define PT_SELECT_INFO_MVCC_LOCK_NEEDED 0x8000 /* lock returned rows */
#define PT_SELECT_INFO_READ_ONLY 0x010000 /* read-only system generated queries like show statement */
#define PT_SELECT_INFO_IS_FLAGED(s, f) \
((s)->info.query.q.select.flag & (f))
#define PT_SELECT_INFO_SET_FLAG(s, f) \
(s)->info.query.q.select.flag |= (f)
#define PT_SELECT_INFO_CLEAR_FLAG(s, f) \
(s)->info.query.q.select.flag &= ~(f)
/* common with union and select info */
struct pt_query_info
{
int correlation_level; /* for correlated subqueries */
PT_MISC_TYPE all_distinct; /* enum value is PT_ALL or PT_DISTINCT */
PT_MISC_TYPE is_subquery; /* PT_IS_SUB_QUERY, PT_IS_UNION_QUERY, PT_IS_CTE_NON_REC_SUBQUERY,
* PT_IS_CTE_REC_SUBQUERY or 0 */
char is_view_spec; /* 0 - normal, 1 - view query spec */
char oids_included; /* DB_NO_OIDS/0 DB_ROW_OIDS/1 */
SCAN_OPERATION_TYPE scan_op_type; /* scan operation type */
int upd_del_class_cnt; /* number of classes affected by update or delete in the generated SELECT statement */
int mvcc_reev_extra_cls_cnt; /* number of extra OID - CLASS_OID pairs added to the select list for condition and
* assignment reevaluation in MVCC */
struct
{
unsigned has_outer_spec:1; /* has outer join spec ? */
unsigned is_sort_spec:1; /* query is a sort spec expression */
unsigned is_insert_select:1; /* query is a sub-select for insert statement */
unsigned single_tuple:1; /* is single-tuple query ? */
unsigned vspec_as_derived:1; /* is derived from vclass spec ? */
unsigned reexecute:1; /* should be re-executed; not from the result caceh */
unsigned do_cache:1; /* do cache the query result */
unsigned do_not_cache:1; /* do not cache the query result */
unsigned order_siblings:1; /* flag ORDER SIBLINGS BY */
unsigned rewrite_limit:1; /* need to rewrite the limit clause */
unsigned has_system_class:1; /* do not cache the query result */
unsigned subquery_cached:1; /* subquery is cached */
} flag;
PT_NODE *order_by; /* PT_EXPR (list) */
PT_NODE *orderby_for; /* PT_EXPR (list) */
PT_NODE *into_list; /* PT_VALUE (list) */
PT_NODE *qcache_hint; /* enable/disable query cache */
PT_NODE *limit; /* PT_VALUE (list) limit clause parameter(s) */
void *xasl; /* xasl proc pointer */
XASL_ID *sub_xasl_id; /* xasl_id for cached subquery */
UINTPTR id; /* query unique id # */
PT_HINT_ENUM hint; /* hint flag */
bool is_order_dependent; /* true if query is order dependent */
PT_NODE *with; /* PT_WITH_CLAUSE */
union
{
PT_SELECT_INFO select;
PT_UNION_INFO union_;
} q;
};
/* Info for Set Optimization Level statement */
struct pt_set_opt_lvl_info
{
PT_NODE *val; /* PT_VALUE */
PT_MISC_TYPE option; /* PT_OPT_LVL, PT_OPT_COST */
};
/* Info for Set Parameters statement */
struct pt_set_sys_params_info
{
PT_NODE *val; /* PT_VALUE */
};
/* Info for Set Transaction statement */
struct pt_set_xaction_info
{
PT_NODE *xaction_modes; /* PT_ISOLATION_LVL, PT_TIMEOUT (list) */
};
/* Info for Set Trigger statement */
struct pt_set_trigger_info
{
PT_NODE *val; /* PT_VALUE */
PT_MISC_TYPE option; /* PT_TRIGGER_DEPTH, PT_TRIGGER_TRACE */
};
/* Info for PT_SHOWSTMT node */
struct pt_showstmt_info
{
SHOWSTMT_TYPE show_type; /* show statement type */
PT_NODE *show_args; /* show statement args */
};
struct pt_killstmt_info
{
KILLSTMT_TYPE kill_type;
PT_NODE *tran_id_list;
};
/* Info for OrderBy/GroupBy */
struct pt_sort_spec_info
{
PT_NODE *expr; /* PT_EXPR, PT_VALUE, PT_NAME */
QFILE_TUPLE_VALUE_POSITION pos_descr; /* Value position descriptor */
PT_MISC_TYPE asc_or_desc; /* enum value will be PT_ASC or PT_DESC */
PT_MISC_TYPE nulls_first_or_last; /* enum value will be PT_NULLS_DEFAULT, PT_NULLS_FIRST or PT_NULLS_LAST */
};
/* Info for Transaction Timeout */
struct pt_timeout_info
{
PT_NODE *val; /* PT_VALUE */
};
/* Info for Trigger Action */
struct pt_trigger_action_info
{
PT_NODE *expression; /* parse tree for expression */
PT_NODE *string; /* PT_PRINT string */
PT_MISC_TYPE action_type; /* REJECT, INVALIDATE_XACTION, etc. */
};
/* Info for Trigger Spec List */
struct pt_trigger_spec_list_info
{
PT_NODE *trigger_name_list; /* PT_NAME (list), or */
PT_NODE *event_list; /* PT_EVENT_SPEC (list), or */
int all_triggers; /* 1 iff ALL TRIGGERS */
};
/* Info for UPDATE node */
struct pt_update_info
{
PT_NODE *spec; /* SPEC */
PT_NODE *class_specs; /* PT_SPEC list */
PT_NODE *assignment; /* EXPR(list) */
PT_NODE *search_cond; /* EXPR */
PT_NODE *using_index; /* PT_NAME (list) */
DB_OBJECT *object; /* for single object up */
PT_NODE *object_parameter; /* parameter node */
PT_NODE *cursor_name; /* PT_NAME */
PT_NODE *check_where; /* with check option predicate */
PT_NODE *internal_stmts; /* internally created statements to handle TEXT */
PT_NODE *waitsecs_hint; /* lock timeout in seconds */
PT_NODE *leading_hint; /* LEADING hint's arguments (PT_NAME list) */
PT_NODE *use_nl_hint; /* USE_NL hint's arguments (PT_NAME list) */
PT_NODE *use_idx_hint; /* USE_IDX hint's arguments (PT_NAME list) */
PT_NODE *use_merge_hint; /* USE_MERGE hint's arguments (PT_NAME list) */
PT_NODE *no_use_hash_hint; /* NO_USE_HASH hint's arguments (PT_NAME list) */
PT_NODE *use_hash_hint; /* USE_HASH hint's arguments (PT_NAME list) */
PT_NODE *limit; /* PT_VALUE limit clause parameter */
PT_NODE *order_by; /* PT_EXPR (list) */
PT_NODE *orderby_for; /* PT_EXPR */
PT_HINT_ENUM hint; /* hint flag */
PT_NODE *with; /* PT_WITH_CLAUSE */
int num_parallel_threads; /* number of parallel threads */
unsigned has_trigger:1; /* whether it has triggers */
unsigned has_unique:1; /* whether there's unique constraint */
unsigned server_update:1; /* whether it can be server-side update */
unsigned do_class_attrs:1; /* whether it is on class attributes */
unsigned rewrite_limit:1; /* need to rewrite the limit clause */
unsigned execute_with_commit_allowed:1; /* true, if execute with commit allowed. */
};
/* UPDATE STATISTICS INFO */
struct pt_update_stats_info
{
PT_NODE *class_list; /* PT_NAME */
int all_classes; /* 1 iff ALL CLASSES */
int with_fullscan; /* 1 iff WITH FULLSCAN */
};
/* GET STATISTICS INFO */
struct pt_get_stats_info
{
PT_NODE *class_; /* PT_NAME */
PT_NODE *args; /* PT_VALUE character_string_literal */
PT_NODE *into_var; /* PT_VALUE */
};
#if defined (ENABLE_UNUSED_FUNCTION)
struct pt_use_info
{
PT_NODE *use_list;
PT_NODE *exclude_list;
PT_MISC_TYPE relative; /* 0 = absolute, PT_CURRENT = relative to current, or PT_DEFAULT = relative to default */
char as_default; /* If non zero, change the default, instead of the current setting */
};
#endif
/* Info for table options */
struct pt_table_option_info
{
PT_TABLE_OPTION_TYPE option; /* The table option type */
PT_NODE *val; /* PT_VALUE */
};
/* Info for MERGE statement */
struct pt_merge_info
{
PT_NODE *into; /* INTO PT_SPEC */
PT_NODE *using_clause; /* USING PT_SPEC */
PT_NODE *search_cond; /* PT_EXPR */
struct
{
PT_NODE *assignment; /* PT_EXPR (list) */
PT_NODE *search_cond; /* PT_EXPR */
PT_NODE *del_search_cond; /* PT_EXPR */
PT_NODE *index_hint; /* PT_NAME (list) */
bool do_class_attrs; /* whether it is on class attributes */
bool has_delete; /* whether it has a delete clause */
} update;
struct
{
PT_NODE *attr_list; /* PT_NAME */
PT_NODE *value_clauses; /* PT_NODE_LIST (list) */
PT_NODE *search_cond; /* PT_EXPR */
PT_NODE *class_where; /* PT_EXPR */
PT_NODE *index_hint; /* PT_NAME (list) */
} insert;
PT_NODE *check_where; /* check option */
PT_NODE *waitsecs_hint; /* lock timeout in seconds */
PT_HINT_ENUM hint; /* hint flag */
PT_NODE *no_use_hash; /* NO_USE_HASH hint's arguments (PT_NAME list) */
PT_NODE *use_hash; /* USE_HASH hint's arguments (PT_NAME list) */
#define PT_MERGE_INFO_HAS_UNIQUE 1 /* has unique constraints */
#define PT_MERGE_INFO_SERVER_OP 2 /* server side operation */
#define PT_MERGE_INFO_INSERT_ONLY 4 /* merge condition always false */
short flags; /* statement specific flags */
};
/* Info for SET NAMES */
struct pt_set_names_info
{
PT_NODE *charset_node; /* PT_VALUE */
PT_NODE *collation_node; /* PT_VALUE */
};
struct pt_set_timezone_info
{
PT_NODE *timezone_node; /* PT_VALUE */
};
/* Info for VALUE nodes
these are intended to parallel the definitions in dbi.h and be
identical whenever possible
*/
/* enum Time Zones */
typedef enum pt_time_zones
{
PT_TIMEZONE_EASTERN,
PT_TIMEZONE_CENTRAL,
PT_TIMEZONE_MOUNTAIN,
PT_TIMEZONE_PACIFIC
} PT_TIMEZONE;
/* typedefs for TIME and DATE */
typedef long PT_TIME;
typedef long PT_UTIME;
typedef DB_TIMESTAMPTZ PT_TIMESTAMPTZ;
typedef long PT_DATE;
typedef DB_DATETIME PT_DATETIME;
typedef DB_DATETIMETZ PT_DATETIMETZ;
/* enum currency types */
typedef enum pt_currency_types
{
PT_CURRENCY_DOLLAR,
PT_CURRENCY_YEN,
PT_CURRENCY_BRITISH_POUND,
PT_CURRENCY_WON,
PT_CURRENCY_TL,
PT_CURRENCY_CAMBODIAN_RIEL,
PT_CURRENCY_CHINESE_RENMINBI,
PT_CURRENCY_INDIAN_RUPEE,
PT_CURRENCY_RUSSIAN_RUBLE,
PT_CURRENCY_AUSTRALIAN_DOLLAR,
PT_CURRENCY_CANADIAN_DOLLAR,
PT_CURRENCY_BRASILIAN_REAL,
PT_CURRENCY_ROMANIAN_LEU,
PT_CURRENCY_EURO,
PT_CURRENCY_SWISS_FRANC,
PT_CURRENCY_DANISH_KRONE,
PT_CURRENCY_NORWEGIAN_KRONE,
PT_CURRENCY_BULGARIAN_LEV,
PT_CURRENCY_VIETNAMESE_DONG,
PT_CURRENCY_CZECH_KORUNA,
PT_CURRENCY_POLISH_ZLOTY,
PT_CURRENCY_SWEDISH_KRONA,
PT_CURRENCY_CROATIAN_KUNA,
PT_CURRENCY_SERBIAN_DINAR,
PT_CURRENCY_NULL
} PT_CURRENCY;
/* struct for money */
struct pt_monetary_value
{
double amount;
PT_CURRENCY type;
};
struct pt_enum_element_value
{
unsigned short short_val;
PARSER_VARCHAR *str_val;
};
/* Union of datavalues */
union pt_data_value
{
long i;
DB_BIGINT bigint;
float f;
double d;
PARSER_VARCHAR *str; /* keeps as string different data type: string data types (char, byte) date and
* time data types numeric */
void *p; /* what is this */
DB_OBJECT *op;
PT_TIME time;
PT_DATE date;
PT_UTIME utime; /* used for TIMESTAMP and TIMESTAMPLTZ */
PT_TIMESTAMPTZ timestamptz;
PT_DATETIME datetime; /* used for DATETIME and DATETIMELTZ */
PT_DATETIMETZ datetimetz;
PT_MONETARY money;
PT_NODE *set; /* constant sets */
DB_ELO elo; /* ??? */
int b;
PT_ENUM_ELEMENT enumeration;
};
/* Info for the VALUE node */
struct pt_value_info
{
const char *text; /* printed text of a value or of an expression folded to a value. NOTE: this is not the
* actual value of the node. Use value in data_value instead. */
PT_DATA_VALUE data_value; /* see above UNION defs */
DB_VALUE db_value;
short db_value_is_initialized;
short db_value_is_in_workspace;
short location; /* 0 : WHERE; n : join condition of n-th FROM */
char string_type; /* ' ', 'N', 'B', or 'X' */
bool print_charset;
bool print_collation;
bool has_cs_introducer; /* 1 if charset introducer is used for string node e.g. _utf8'a'; 0 otherwise. */
bool is_collate_allowed; /* 1 if this is a PT_VALUE allowed to have the COLLATE modifier (the grammar context in
* which is created allows it) */
bool is_false_where; /* reduced node from false where */
int coll_modifier; /* collation modifier = collation + 1 */
int host_var_index; /* save the host_var index which it comes from. -1 means it is a normal value. it does
* not come from any host_var. */
};
/* Info for the ZZ_ERROR_MSG node */
struct PT_ZZ_ERROR_MSG_INFO
{
char *error_message; /* a helpful explanation of the error */
int statement_number; /* statement where error was detected */
};
/* Info for the FOREIGN KEY node */
struct pt_foreign_key_info
{
PT_NODE *attrs; /* List of attribute names */
PT_NODE *referenced_class; /* Class name */
PT_NODE *referenced_attrs; /* List of attribute names */
PT_MISC_TYPE match_type; /* full or partial */
PT_MISC_TYPE delete_action;
PT_MISC_TYPE update_action;
short deduplicate_level; /* 0 : Not Use, others : mod by pow(2,deduplicate_level), refer to DEDUPLICATE_KEY_LEVEL_??? */
};
/* Info for the CONSTRAINT node */
struct pt_constraint_info
{
PT_NODE *name;
PT_CONSTRAINT_TYPE type;
short deferrable;
short initially_deferred;
union
{
struct
{
PT_NODE *attrs; /* List of attribute names */
} primary_key;
PT_FOREIGN_KEY_INFO foreign_key;
struct
{
PT_NODE *attr; /* Attribute name */
} not_null;
struct
{
PT_NODE *attrs; /* List of attribute names */
} unique;
struct
{
PT_NODE *expr; /* Search condition */
} check;
} un;
PT_NODE *comment;
};
/* POINTER node types */
enum pt_pointer_type
{
PT_POINTER_NORMAL = 0, /* normal pointer, gets resolved to node */
PT_POINTER_REF = 1 /* reference pointer - node gets walked by pt_walk_tree */
};
typedef enum pt_pointer_type PT_POINTER_TYPE;
/* Info for the POINTER node */
struct pt_pointer_info
{
PT_NODE *node; /* original node pointer */
PT_POINTER_TYPE type; /* pointer type (normal pointer/reference) */
double sel; /* selectivity factor of the predicate */
int rank; /* rank factor for the same selectivity */
int pred_order; /* for view-merge or predicate-push. pred is ordered by pred_order */
bool do_walk; /* apply walk on node bool */
};
struct pt_stored_proc_body_info
{
int lang;
PT_NODE *decl; /* PT_VALUE */
PT_NODE *impl; /* PT_VALUE */
};
struct pt_stored_proc_info
{
PT_NODE *name;
PT_NODE *param_list;
PT_NODE *body;
PT_NODE *comment;
PT_NODE *owner; /* for ALTER PROCEDURE/FUNCTION name OWNER TO new_owner */
PT_MISC_TYPE auth_id; /* PT_AUTHID_OWNER, PT_AUTHID_CALLER */
PT_MISC_TYPE dtrm_type; /* PT_NOT_DETERMINISTIC, PT_DETERMINISTIC */
PT_MISC_TYPE type;
unsigned or_replace:1; /* OR REPLACE clause */
PT_TYPE_ENUM ret_type;
PT_NODE *ret_data_type;
int recompile;
};
struct pt_prepare_info
{
PT_NODE *name; /* the name of the prepared statement */
PT_NODE *statement; /* the string literal that defines the statement */
PT_NODE *using_list; /* the list of values given for statement execution */
};
struct pt_execute_info
{
PT_NODE *name; /* the name of the prepared statement */
PT_NODE *query; /* the string literal that defines the statement */
PT_NODE *using_list; /* the list of values given for statement execution */
PT_NODE *into_list; /* for a prepared select using into */
XASL_ID xasl_id; /* XASL id */
CUBRID_STMT_TYPE stmt_type; /* statement type */
int recompile; /* not 0 if this statement should be recompiled */
int do_cache; /* query uses result cache */
int column_count; /* select list column count */
int oids_included; /* OIDs included in select list */
};
struct pt_stored_proc_param_info
{
PT_NODE *name; /* PT_NAME */
PT_MISC_TYPE mode; /* PT_INPUT, PT_OUTPUT, PT_INPUTOUTPUT */
PT_NODE *default_value; /* PT_DATA_DEFAULT */
PT_NODE *comment;
};
/* TRUNCATE ENTITY INFO */
struct pt_truncate_info
{
PT_NODE *spec; /* PT_SPEC */
bool is_cascade; /* whether to truncate cascade FK-referring classes */
};
/* DO ENTITY INFO */
struct pt_do_info
{
PT_NODE *expr; /* PT_EXPR */
};
struct pt_set_session_variable_info
{
PT_NODE *assignments;
};
/* Retains expressions for check when 'with check option' option is specified. Used in update statement */
struct pt_check_option_info
{
UINTPTR spec_id; /* id of spec for wich to check condition */
PT_NODE *expr; /* condition to check */
};
/* info structure for a node which can be evaluated during constant folding as a value of a tuple from a cursor */
struct pt_tuple_value_info
{
PT_NODE *name; /* name alias in the original query */
CURSOR_ID *cursor_p; /* cursor from which the value can be read */
int index; /* index of the value in cursor */
};
struct pt_trace_info
{
PT_MISC_TYPE on_off;
PT_MISC_TYPE format;
};
/* pt_with_clause_info - Parse tree node info which contains CTEs data(used by DML statements) */
struct pt_with_clause_info
{
int recursive;
PT_NODE *cte_definition_list; /* PT_CTE (list) */
};
/* pt_insert_value_info - Parse tree node info used to replace nodes in insert value list after being evaluated. */
struct pt_insert_value_info
{
PT_NODE *original_node; /* original node before first evaluation. if this is NULL, it is considered that
* evaluated value cannot change on different execution, and reevaluation is not needed */
DB_VALUE value; /* evaluated value */
int is_evaluated; /* true if value was already evaluated */
int replace_names; /* true if names in evaluated node need to be replaced */
};
struct pt_json_table_column_info
{
PT_NODE *name;
// domain is stored in parser node
char *path;
size_t index; // will be used to store the columns in the correct order
enum json_table_column_function func;
struct json_table_column_behavior on_error;
struct json_table_column_behavior on_empty;
};
struct pt_json_table_node_info
{
PT_NODE *columns;
PT_NODE *nested_paths;
char *path;
};
struct pt_json_table_info
{
PT_NODE *expr;
PT_NODE *tree;
bool is_correlated;
};
typedef struct host_vars_info
{
int count;
int *index;
} PT_HOST_VAR_IDX_INFO;
typedef struct pt_dblink_info
{
PT_NODE *conn; /* name for DBLINK */
PT_NODE *owner_name;
PT_NODE *url; /* url info */
PT_NODE *user;
PT_NODE *pwd;
PT_NODE *qstr; /* query string */
PT_NODE *cols; /* column definition */
PT_NODE *pushed_pred; /* pushed predicate from main query */
PARSER_VARCHAR *rewritten; /* rewritten query string for dblink */
PT_HOST_VAR_IDX_INFO host_vars; /* host variable index info for rewritten query */
bool is_name; /* */
char *remote_table_name;
PT_NODE *sel_list;
PT_NODE *owner_list;
void *remote_col_list; /* remote table's column list */
} PT_DBLINK_INFO;
typedef struct pt_create_server_info
{
PT_NODE *server_name;
PT_NODE *owner_name;
PT_NODE *host;
PT_NODE *port;
PT_NODE *dbname;
PT_NODE *user;
PT_NODE *pwd;
PT_NODE *prop;
PT_NODE *comment;
} PT_CREATE_SERVER_INFO;
typedef struct pt_alter_server_info
{
PT_NODE *server_name;
PT_NODE *current_owner_name;
PT_NODE *host;
PT_NODE *port;
PT_NODE *dbname;
PT_NODE *user;
PT_NODE *pwd;
PT_NODE *prop;
PT_NODE *comment;
PT_NODE *owner_name;
struct
{
unsigned int bit_host:1;
unsigned int bit_port:1;
unsigned int bit_dbname:1;
unsigned int bit_user:1;
unsigned int bit_pwd:1;
unsigned int bit_prop:1;
unsigned int bit_comment:1;
unsigned int bit_owner:1;
} xbits;
} PT_ALTER_SERVER_INFO;
typedef struct pt_drop_server_info
{
bool if_exists; /* IF EXISTS clause for DROP SERVER */
PT_NODE *owner_name; /* name */
PT_NODE *server_name; /* name */
} PT_DROP_SERVER_INFO;
typedef struct pt_rename_server_info
{
PT_NODE *old_name; /* PT_NAME */
PT_NODE *owner_name; /* name */
PT_NODE *new_name; /* PT_NAME */
} PT_RENAME_SERVER_INFO;
struct pt_synonym_info
{
PT_NODE *synonym_name; /* PT_NAME */
PT_NODE *synonym_owner_name; /* PT_NAME */
PT_NODE *old_synonym_name; /* PT_NAME */
PT_NODE *old_synonym_owner_name; /* PT_NAME */
PT_NODE *new_synonym_name; /* PT_NAME */
PT_NODE *new_synonym_owner_name; /* PT_NAME */
PT_NODE *target_name; /* PT_NAME */
PT_NODE *target_owner_name; /* PT_NAME */
PT_MISC_TYPE access_modifier; /* PT_MISC_TYPE */
PT_NODE *comment; /* PT_VALUE */
unsigned or_replace:1; /* OR REPLACE clause for CREATE SYNONYM */
unsigned if_exists:1; /* IF EXISTS clause for DROP SYNONYM */
unsigned is_dblinked:1; /* server name specified */
};
/* Info field of the basic NODE
If 'xyz' is the name of the field, then the structure type should be
struct PT_XYZ_INFO xyz;
List in alphabetical order.
*/
union pt_statement_info
{
PT_ZZ_ERROR_MSG_INFO error_msg;
PT_ALTER_INFO alter;
PT_ALTER_TRIGGER_INFO alter_trigger;
PT_ALTER_USER_INFO alter_user;
PT_ALTER_SERVER_INFO alter_server;
PT_ATTACH_INFO attach;
PT_ATTR_DEF_INFO attr_def;
PT_ATTR_ORDERING_INFO attr_ordering;
PT_AUTH_CMD_INFO auth_cmd;
PT_AUTO_INCREMENT_INFO auto_increment;
PT_CHECK_OPTION_INFO check_option;
PT_COMMIT_WORK_INFO commit_work;
PT_CONSTRAINT_INFO constraint;
PT_CREATE_ENTITY_INFO create_entity;
PT_CREATE_SERVER_INFO create_server;
PT_CREATE_TRIGGER_INFO create_trigger;
PT_CREATE_USER_INFO create_user;
PT_CTE_INFO cte;
PT_DATA_DEFAULT_INFO data_default;
PT_DATA_TYPE_INFO data_type;
PT_DBLINK_INFO dblink_table;
PT_DELETE_INFO delete_;
PT_DO_INFO do_;
PT_DOT_INFO dot;
PT_DROP_INFO drop;
PT_DROP_SESSION_VAR_INFO drop_session_var;
PT_DROP_SERVER_INFO drop_server;
PT_DROP_TRIGGER_INFO drop_trigger;
PT_DROP_USER_INFO drop_user;
PT_DROP_VARIABLE_INFO drop_variable;
PT_EVALUATE_INFO evaluate;
PT_EVENT_OBJECT_INFO event_object;
PT_EVENT_SPEC_INFO event_spec;
PT_EVENT_TARGET_INFO event_target;
PT_EXECUTE_INFO execute;
PT_EXECUTE_TRIGGER_INFO execute_trigger;
PT_EXPR_INFO expr;
PT_FILE_PATH_INFO file_path;
PT_FUNCTION_INFO function;
PT_GET_OPT_LVL_INFO get_opt_lvl;
PT_GET_STATS_INFO get_stats;
PT_GET_TRIGGER_INFO get_trigger;
PT_GET_XACTION_INFO get_xaction;
PT_GRANT_INFO grant;
PT_HOST_VAR_INFO host_var;
PT_INDEX_INFO index;
PT_INSERT_INFO insert;
PT_INSERT_VALUE_INFO insert_value;
PT_ISOLATION_LVL_INFO isolation_lvl;
PT_JSON_TABLE_INFO json_table_info;
PT_JSON_TABLE_NODE_INFO json_table_node_info;
PT_JSON_TABLE_COLUMN_INFO json_table_column_info;
PT_MERGE_INFO merge;
PT_METHOD_CALL_INFO method_call;
PT_METHOD_DEF_INFO method_def;
PT_NAME_INFO name;
PT_NAMED_ARG_INFO named_arg;
PT_NODE_LIST_INFO node_list;
PT_PARTITION_INFO partition;
PT_PARTS_INFO parts;
PT_PREPARE_INFO prepare;
PT_ATTACH_INFO prepare_to_commit;
PT_QUERY_INFO query;
PT_REMOVE_TRIGGER_INFO remove_trigger;
PT_RENAME_INFO rename;
PT_RENAME_SERVER_INFO rename_server;
PT_RENAME_TRIGGER_INFO rename_trigger;
PT_RESOLUTION_INFO resolution;
PT_REVOKE_INFO revoke;
PT_ROLLBACK_WORK_INFO rollback_work;
PT_SAVEPOINT_INFO savepoint;
PT_SCOPE_INFO scope;
PT_SERIAL_INFO serial;
PT_SET_NAMES_INFO set_names;
PT_SET_TIMEZONE_INFO set_timezone;
PT_SET_OPT_LVL_INFO set_opt_lvl;
PT_SET_SYS_PARAMS_INFO set_sys_params;
PT_SET_TRIGGER_INFO set_trigger;
PT_SET_SESSION_VARIABLE_INFO set_variables;
PT_SET_XACTION_INFO set_xaction;
PT_SHOWSTMT_INFO showstmt;
PT_SORT_SPEC_INFO sort_spec;
PT_STORED_PROC_INFO sp;
PT_STORED_PROC_PARAM_INFO sp_param;
PT_SPEC_INFO spec;
PT_SYNONYM_INFO synonym;
PT_TABLE_OPTION_INFO table_option;
PT_TIMEOUT_INFO timeout;
PT_TRIGGER_ACTION_INFO trigger_action;
PT_TRIGGER_SPEC_LIST_INFO trigger_spec_list;
PT_TRUNCATE_INFO truncate;
PT_TUPLE_VALUE_INFO tuple_value;
PT_UPDATE_INFO update;
PT_UPDATE_STATS_INFO update_stats;
#if defined (ENABLE_UNUSED_FUNCTION)
PT_USE_INFO use;
#endif
PT_VALUE_INFO value;
PT_POINTER_INFO pointer;
PT_TRACE_INFO trace;
PT_KILLSTMT_INFO killstmt;
PT_WITH_CLAUSE_INFO with_clause;
PT_SP_BODY_INFO sp_body;
};
/*
* auxiliary structures for tree walking operations related to aggregates
*/
struct pt_agg_check_info
{
PT_NODE *from; /* initial spec list */
PT_NODE *group_by; /* group by list */
int depth; /* current depth */
};
struct pt_agg_rewrite_info
{
PT_NODE *select_stack; /* SELECT statement stack (0 = base) */
PT_NODE *from; /* initial spec list */
PT_NODE *new_from; /* new spec */
PT_NODE *derived_select; /* initial select (that is being derived) */
int depth;
};
struct pt_agg_find_info
{
PT_NODE *select_stack; /* SELECT statement stack (0 = base) */
int base_count; /* # of aggregate functions that belong to the statement at the base of the stack */
int out_of_context_count; /* # of aggregate functions that do not belong to any statement within the stack */
bool stop_on_subquery; /* walk subqueries? */
bool disable_loose_scan; /* true if loose index scan cannot be used */
};
struct pt_agg_name_info
{
PT_NODE *select_stack; /* SELECT statement stack (0 = base) */
int max_level; /* maximum level within the stack that is is referenced by PT_NAMEs */
int name_count; /* # of PT_NAME nodes found */
};
struct pt_filter_index_info
{
PT_NODE *atts; /* attributes */
int atts_count; /* attributes count */
int depth; /* expression depth */
bool *is_null_atts; /* for each filter index attribute true, when "is null index_attribute" term is
* contained in filter index expression */
bool has_keys_in_expression; /* true, if an index key appear in expression */
bool is_constant_expression; /* true, if expression is constant */
bool is_valid_expr; /* true, if invalid filter index expression */
bool has_not; /* true, when not operator is found in filter index expression */
};
struct pt_non_groupby_col_info
{
PT_NODE *groupby;
bool has_non_groupby_col;
};
struct pt_flat_spec_info
{
PT_NODE *spec_parent;
bool for_update;
};
/*
* variable string for parser
*/
struct parser_varchar
{
int length;
unsigned char bytes[1];
};
/*
* The parser node structure
*/
struct parser_node
{
PT_NODE_TYPE node_type; /* the type of SQL statement this represents */
int parser_id; /* which parser did I come from */
int line_number; /* the user line number originating this */
int column_number; /* the user column number originating this */
int buffer_pos; /* position in the parse buffer of the string originating this */
char *sql_user_text; /* user input sql string */
int sql_user_text_len; /* user input sql string length (one statement) */
PT_NODE *next; /* forward link for NULL terminated list */
PT_NODE *or_next; /* forward link for DNF list */
PT_NODE *next_row; /* for PT_VALUE,PT_NAME,PT_EXPR... that belongs to PT_NODE_LIST */
void *etc; /* application specific info hook */
UINTPTR spec_ident; /* entity spec equivalence class */
TP_DOMAIN *expected_domain; /* expected domain for input marker */
PT_NODE *data_type; /* for non-primitive types, Sets, objects stec. */
XASL_ID *xasl_id; /* XASL_ID for this SQL statement */
const char *alias_print; /* the column alias */
PARSER_VARCHAR *expr_before_const_folding; /* text before constant folding (used by value, host var nodes) */
PT_TYPE_ENUM type_enum; /* type enumeration tag PT_TYPE_??? */
CACHE_TIME cache_time; /* client or server cache time */
int sub_host_var_count; /* subquery's host variable count */
int *sub_host_var_index; /* subquery's host variable index */
struct
{
unsigned recompile:1; /* the statement should be recompiled - used for plan cache */
unsigned cannot_prepare:1; /* the statement cannot be prepared - used for plan cache */
unsigned partition_pruned:1; /* partition pruning takes place */
unsigned si_datetime:1; /* get server info; SYS_DATETIME */
unsigned si_tran_id:1; /* get server info; LOCAL_TRANSACTION_ID */
unsigned clt_cache_check:1; /* check client cache validity */
unsigned clt_cache_reusable:1; /* client cache is reusable */
unsigned use_plan_cache:1; /* used for plan cache */
unsigned use_query_cache:1;
unsigned is_hidden_column:1;
unsigned is_paren:1;
unsigned with_rollup:1; /* WITH ROLLUP clause for GROUP BY */
unsigned force_auto_parameterize:1; /* forces a call to qo_auto_parameterize (); this is a special flag used for
* processing ON DUPLICATE KEY UPDATE */
unsigned do_not_fold:1; /* disables constant folding on the node */
unsigned is_cnf_start:1;
unsigned is_click_counter:1; /* INCR/DECR(click counter) */
unsigned is_value_query:1; /* for PT_VALUE,PT_NAME,PT_EXPR... that belongs to PT_NODE_LIST for PT_SELECT that
* "values" generated */
unsigned do_not_replace_orderby:1; /* when checking query in create/alter view, do not replace order by */
unsigned is_added_by_parser:1; /* is added by parser during parsing */
unsigned is_alias_enabled_expr:1; /* node allowed to have alias */
unsigned is_wrapped_res_for_coll:1; /* is a result node wrapped with CAST by collation inference */
unsigned is_system_generated_stmt:1; /* is internally generated by system */
unsigned use_auto_commit:1; /* use autocommit */
unsigned done_reduce_equality_terms:1; /* reduce_equality_terms() is already called */
unsigned print_in_value_for_dblink:1; /* for select ... where in (...) to print (...) not {...} */
unsigned do_not_use_subquery_cache:1; /* for subquery cache re-execute */
unsigned for_default_func:1; /* for DEFAULT built-in function */
} flag;
PT_STATEMENT_INFO info; /* depends on 'node_type' field */
};
/* Values that describe the state of a client session across statements
* execution.
*/
typedef struct execution_state_values EXECUTION_STATE_VALUES;
struct execution_state_values
{
int row_count; /* The number of rows that were inserted, updated or deleted by the previously executed
* statement. It is set to -1 on certain errors or if the previous statement did not
* modify any rows. */
};
/* 20 (for the LOCAL_TRANSACTION_ID keyword) + null char + 3 for expansion */
#define MAX_KEYWORD_SIZE (20 + 1 + 3)
typedef struct keyword_record KEYWORD_RECORD;
struct keyword_record
{
#if defined(ENABLE_UNUSED_FUNCTION)
short value;
#else
unsigned short hash_value;
#endif
char keyword[MAX_KEYWORD_SIZE];
short unreserved; /* keyword can be used as an identifier, 0 means it is reserved and cannot be used as
* an identifier, nonzero means it can be */
};
typedef struct function_map FUNCTION_MAP;
struct function_map
{
unsigned short hash_value;
const char *keyword;
int op;
};
typedef struct pt_plan_trace_info
{
QUERY_TRACE_FORMAT format;
union
{
char *text_plan;
struct json_t *json_plan;
} trace;
} PT_PLAN_TRACE_INFO;
/* to save the remote column list for dblink */
typedef struct remote_cols
{
void *cols;
struct remote_cols *next;
} REMOTE_COLS;
typedef int (*PT_CASECMP_FUN) (const char *s1, const char *s2);
typedef int (*PT_INT_FUNCTION) (PARSER_CONTEXT * c);
struct parser_context
{
PT_INT_FUNCTION next_char; /* the next character function */
PT_INT_FUNCTION next_byte; /* the next byte function */
PT_CASECMP_FUN casecmp; /* for case insensitive comparisons */
int id; /* internal parser id */
int statement_number; /* user-initialized, incremented by parser */
const char *original_buffer; /* pointer to the original parse buffer */
const char *buffer; /* for parse buffer */
FILE *file; /* for parse file */
int stack_top; /* parser stack top */
int stack_size; /* total number of slots in node_stack */
PT_NODE **node_stack; /* the parser stack */
PT_NODE *orphans; /* list of parse tree fragments freed later */
char *error_buffer; /* for parse error messages */
PT_NODE **statements; /* array of statement pointers */
PT_NODE *error_msgs; /* list of parsing error messages */
PT_NODE *warnings; /* list of warning messages */
PT_PRINT_VALUE_FUNC print_db_value;
jmp_buf jmp_env; /* environment for longjumping on out of memory errors. */
unsigned int custom_print;
int jmp_env_active; /* flag to indicate jmp_env status */
QUERY_ID query_id; /* id assigned to current query */
DB_VALUE *host_variables; /* host variables place holder; DB_VALUE array */
TP_DOMAIN **host_var_expected_domains; /* expected domains for host variables */
EXECUTION_STATE_VALUES execution_values; /* values kept across the execution of statements during a client
* session. */
int host_var_count; /* number of input host variables */
int auto_param_count; /* number of auto parameterized variables */
int dbval_cnt; /* to be assigned to XASL */
int line, column; /* current input line and column */
void *etc; /* application context */
VIEW_CACHE_INFO *view_cache; /* parsing cache using in view transformation */
struct symbol_info *symbols; /* a place to keep information used in generating query processing (xasl) procedures. */
char **lcks_classes;
size_t input_buffer_length;
size_t input_buffer_position;
int au_save; /* authorization to restore if longjmp while authorization turned off */
DB_VALUE sys_datetime;
DB_VALUE sys_epochtime;
DB_VALUE local_transaction_id;
int num_lcks_classes;
PT_INCLUDE_OID_TYPE oid_included; /* for update cursors */
long int lrand; /* integer random value used by rand() */
double drand; /* floating-point random value used by drand() */
COMPILE_CONTEXT context;
struct xasl_node *parent_proc_xasl;
bool query_trace;
int num_plan_trace;
PT_PLAN_TRACE_INFO plan_trace[MAX_NUM_PLAN_TRACE];
int max_print_len; /* for pt_short_print */
char **external_into_label;
int external_into_label_cnt;
REMOTE_COLS *dblink_remote; /* for dblink, remote column list */
HIDE_PWD_INFO hide_pwd_info;
PARSER_VARCHAR *dblink_server_text; /* Contains access information to be used in generating SHA hash values when using the Server name in DBLINK. */
struct
{
unsigned has_internal_error:1; /* 0 or 1 */
unsigned abort:1; /* this flag is for aborting a transaction */
/* if deadlock occurs during query execution */
unsigned set_host_var:1; /* 1 if the user has set host variables */
unsigned dont_prt_long_string:1; /* make pt_print_value fail if the string is too long to print */
unsigned long_string_skipped:1; /* pt_print_value sets it to 1 when it skipped printing a long string */
unsigned print_type_ambiguity:1; /* pt_print_value sets it to 1 when it printed a value whose type cannot be
* clearly determined from the string representation */
unsigned strings_have_no_escapes:1;
unsigned is_in_and_list:1; /* set to 1 when the caller immediately above is pt_print_and_list(). Used because AND
* lists (CNF trees) can be printed via print_and_list or straight via pt_print_expr().
* We need to keep print_and_list because it could get called before we get a chance to
* mark the CNF start nodes. */
unsigned is_holdable:1; /* set to true if result must be available across commits */
unsigned is_xasl_pinned_reference:1; /* set to 1 if the prepared xasl cache need to be pinned in server side. To
* prevent other thread from preempting the xasl cache again. This will
* happen when a jdbc/cci driver retries to prepare/execute a query due to
* CAS_ER_STMT_POOLING. */
unsigned recompile_xasl_pinned:1; /* set to 1 when recompile again even the xasl cache entry has been pinned */
unsigned dont_collect_exec_stats:1;
unsigned return_generated_keys:1;
unsigned is_system_generated_stmt:1;
unsigned is_auto_commit:1; /* set to true, if auto commit. */
unsigned is_parsing_static_sql:1; /* For PL/CSQL's static SQL: parameterize PL/CSQL variable symbols (to host variable) */
unsigned is_unloading_plcsql_def:1;
unsigned is_parsing_trigger:1;
unsigned is_skip_auto_parameterize:1; /* set to 1 when skip auto parameterize, now only used for merge xasl generation */
unsigned dblink_skip_implicit_serial_qualifier:1; /* DBLink: do not merge current schema into unqualified SERIAL names */
} flag;
};
/* used in assignments enumeration */
typedef struct pt_assignments_helper PT_ASSIGNMENTS_HELPER;
struct pt_assignments_helper
{
PARSER_CONTEXT *parser; /* parser context */
PT_NODE *assignment; /* current assignment node in the assignments list */
PT_NODE *lhs; /* left side of the assignment */
PT_NODE *rhs; /* right side of the assignment */
bool is_rhs_const; /* true if the right side is a constant */
bool is_n_column; /* true if the assignment is a multi-column assignment */
};
/* Collation coercibility levels associated with parse tree nodes */
enum pt_coll_coerc_lev
{
PT_COLLATION_L0_COERC = 0, /* expressions with COLLATE modifier */
/* Columns */
PT_COLLATION_L1_COERC, /* non-binary collations */
PT_COLLATION_L1_ISO_BIN_COERC, /* with ISO binary coll */
PT_COLLATION_L1_BIN_COERC, /* with binary collation */
/* SELECT values, expressions */
PT_COLLATION_L2_COERC, /* non-binary collations */
PT_COLLATION_L2_BINARY_COERC, /* with binary collation */
PT_COLLATION_L2_BIN_COERC, /* with ISO, UTF8 or EUCKR binary collation */
/* special operators (USER()) */
PT_COLLATION_L3_COERC,
/* constants (string literals) */
PT_COLLATION_L4_COERC, /* non-binary collations */
PT_COLLATION_L4_BINARY_COERC, /* with binary collation */
PT_COLLATION_L4_BIN_COERC, /* with ISO, UTF8 or EUCKR binary collation */
/* HV, session variables */
PT_COLLATION_L5_COERC,
/* nodes not having collation (internal use) */
PT_COLLATION_L6_COERC,
PT_COLLATION_NOT_APPLICABLE = PT_COLLATION_L6_COERC,
PT_COLLATION_NOT_COERC = PT_COLLATION_L0_COERC,
PT_COLLATION_FULLY_COERC = PT_COLLATION_L5_COERC
};
typedef enum pt_coll_coerc_lev PT_COLL_COERC_LEV;
typedef struct pt_coll_infer PT_COLL_INFER;
struct pt_coll_infer
{
int coll_id;
INTL_CODESET codeset;
PT_COLL_COERC_LEV coerc_level;
bool can_force_cs; /* used as a weak-modifier for collation coercibility (when node is a host variable). +
* for auto-CAST expressions around numbers: initially the string data type of CAST is
* created with system charset by generic type checking but that charset can be forced
* to another charset (of another argument) if this flag is set */
#ifdef __cplusplus
// *INDENT-OFF*
pt_coll_infer ()
: coll_id (-1)
, codeset (INTL_CODESET_NONE)
, coerc_level (PT_COLLATION_NOT_APPLICABLE)
, can_force_cs (true)
{
//
}
// *INDENT-ON*
#endif // c++
};
enum cdc_ddl_type
{
CDC_CREATE,
CDC_ALTER,
CDC_DROP,
CDC_RENAME,
CDC_TRUNCATE
};
typedef enum cdc_ddl_type CDC_DDL_TYPE;
enum cdc_ddl_object_type
{
CDC_TABLE,
CDC_INDEX,
CDC_SERIAL,
CDC_VIEW,
CDC_FUNCTION,
CDC_PROCEDURE,
CDC_TRIGGER,
CDC_USER
};
typedef enum cdc_ddl_object_type CDC_DDL_OBJECT_TYPE;
typedef struct
{
int local_cnt;
int server_cnt;
int server_node_cnt;
int len[2];
char *server_full_name[2];
PT_NODE *server[2];
bool has_dblink_query;
} SERVER_NAME_LIST;
void pt_init_node (PT_NODE * node, PT_NODE_TYPE node_type);
#ifdef __cplusplus
extern "C"
{
#endif
void *parser_allocate_string_buffer (const PARSER_CONTEXT * parser, const int length, const int align);
bool pt_is_json_value_type (PT_TYPE_ENUM type);
bool pt_is_json_doc_type (PT_TYPE_ENUM type);
#ifdef __cplusplus
}
#endif
#if !defined (SERVER_MODE)
#ifdef __cplusplus
extern "C"
{
#endif
extern PARSER_CONTEXT *parent_parser;
#ifdef __cplusplus
}
#endif
#endif
#endif /* _PARSE_TREE_H_ */