296 lines
14 KiB
C
296 lines
14 KiB
C
/* -------------------------------------------------------------------------
|
|
*
|
|
* parse_node.h
|
|
* Internal definitions for parser
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
* Portions Copyright (c) 2021, openGauss Contributors
|
|
*
|
|
* src/include/parser/parse_node.h
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
#ifndef PARSE_NODE_H
|
|
#define PARSE_NODE_H
|
|
|
|
#include "nodes/parsenodes.h"
|
|
#include "parser/analyze.h"
|
|
#include "utils/relcache.h"
|
|
|
|
typedef struct PlusJoinRTEInfo {
|
|
bool needrecord; /* need record the RTE info for plus join? only in WhereClause is true for now */
|
|
List* info; /* List of PlusJoinRTEItem we record */
|
|
} PlusJoinRTEInfo;
|
|
|
|
/*
|
|
* Expression kinds distinguished by transformExpr(). Many of these are not
|
|
* semantically distinct so far as expression transformation goes; rather,
|
|
* we distinguish them so that context-specific error messages can be printed.
|
|
*
|
|
* Note: EXPR_KIND_OTHER is not used in the core code, but is left for use
|
|
* by extension code that might need to call transformExpr(). The core code
|
|
* will not enforce any context-driven restrictions on EXPR_KIND_OTHER
|
|
* expressions, so the caller would have to check for sub-selects, aggregates,
|
|
* window functions, SRFs, etc if those need to be disallowed.
|
|
*/
|
|
typedef enum ParseExprKind
|
|
{
|
|
EXPR_KIND_NONE = 0, /* "not in an expression" */
|
|
EXPR_KIND_OTHER, /* reserved for extensions */
|
|
EXPR_KIND_JOIN_ON, /* JOIN ON */
|
|
EXPR_KIND_JOIN_USING, /* JOIN USING */
|
|
EXPR_KIND_FROM_SUBSELECT, /* sub-SELECT in FROM clause */
|
|
EXPR_KIND_FROM_FUNCTION, /* function in FROM clause */
|
|
EXPR_KIND_WHERE, /* WHERE */
|
|
EXPR_KIND_HAVING, /* HAVING */
|
|
EXPR_KIND_FILTER, /* FILTER */
|
|
EXPR_KIND_WINDOW_PARTITION, /* window definition PARTITION BY */
|
|
EXPR_KIND_WINDOW_ORDER, /* window definition ORDER BY */
|
|
EXPR_KIND_WINDOW_FRAME_RANGE, /* window frame clause with RANGE */
|
|
EXPR_KIND_WINDOW_FRAME_ROWS, /* window frame clause with ROWS */
|
|
EXPR_KIND_WINDOW_FRAME_GROUPS, /* window frame clause with GROUPS */
|
|
EXPR_KIND_SELECT_TARGET, /* SELECT target list item */
|
|
EXPR_KIND_INSERT_TARGET, /* INSERT target list item */
|
|
EXPR_KIND_UPDATE_SOURCE, /* UPDATE assignment source item */
|
|
EXPR_KIND_UPDATE_TARGET, /* UPDATE assignment target item */
|
|
EXPR_KIND_GROUP_BY, /* GROUP BY */
|
|
EXPR_KIND_ORDER_BY, /* ORDER BY */
|
|
EXPR_KIND_DISTINCT_ON, /* DISTINCT ON */
|
|
EXPR_KIND_LIMIT, /* LIMIT */
|
|
EXPR_KIND_OFFSET, /* OFFSET */
|
|
EXPR_KIND_RETURNING, /* RETURNING */
|
|
EXPR_KIND_VALUES, /* VALUES */
|
|
EXPR_KIND_VALUES_SINGLE, /* single-row VALUES (in INSERT only) */
|
|
EXPR_KIND_CHECK_CONSTRAINT, /* CHECK constraint for a table */
|
|
EXPR_KIND_DOMAIN_CHECK, /* CHECK constraint for a domain */
|
|
EXPR_KIND_COLUMN_DEFAULT, /* default value for a table column */
|
|
EXPR_KIND_FUNCTION_DEFAULT, /* default parameter value for function */
|
|
EXPR_KIND_INDEX_EXPRESSION, /* index expression */
|
|
EXPR_KIND_INDEX_PREDICATE, /* index predicate */
|
|
EXPR_KIND_ALTER_COL_TRANSFORM, /* transform expr in ALTER COLUMN TYPE */
|
|
EXPR_KIND_EXECUTE_PARAMETER, /* parameter value in EXECUTE */
|
|
EXPR_KIND_TRIGGER_WHEN, /* WHEN condition in CREATE TRIGGER */
|
|
EXPR_KIND_POLICY, /* USING or WITH CHECK expr in policy */
|
|
EXPR_KIND_PARTITION_BOUND, /* partition bound expression */
|
|
EXPR_KIND_PARTITION_EXPRESSION, /* PARTITION BY expression */
|
|
EXPR_KIND_CALL_ARGUMENT, /* procedure argument in CALL */
|
|
EXPR_KIND_COPY_WHERE, /* WHERE condition in COPY FROM */
|
|
EXPR_KIND_GENERATED_COLUMN, /* generation expression for a column */
|
|
} ParseExprKind;
|
|
|
|
/*
|
|
* Function signatures for parser hooks
|
|
*/
|
|
typedef struct ParseState ParseState;
|
|
|
|
typedef Node* (*PreParseColumnRefHook)(ParseState* pstate, ColumnRef* cref);
|
|
typedef Node* (*PostParseColumnRefHook)(ParseState* pstate, ColumnRef* cref, Node* var);
|
|
typedef Node* (*ParseParamRefHook)(ParseState* pstate, ParamRef* pref);
|
|
typedef Node* (*CoerceParamHook)(ParseState* pstate, Param* param, Oid targetTypeId, int32 targetTypeMod, int location);
|
|
typedef Node* (*CreateProcOperatorHook)(ParseState* pstate, Node* left, Node* right, Oid* ltypeid, Oid* rtypeid);
|
|
typedef void (*CreateProcInsertrHook)(ParseState* pstate, int param_no, Oid param_new_type, Oid relid,
|
|
const char* col_name);
|
|
typedef void* (*GetFuncinfoFromStateHelper)(void* param);
|
|
|
|
/*
|
|
* State information used during parse analysis
|
|
*
|
|
* parentParseState: NULL in a top-level ParseState. When parsing a subquery,
|
|
* links to current parse state of outer query.
|
|
*
|
|
* p_sourcetext: source string that generated the raw parsetree being
|
|
* analyzed, or NULL if not available. (The string is used only to
|
|
* generate cursor positions in error messages: we need it to convert
|
|
* byte-wise locations in parse structures to character-wise cursor
|
|
* positions.)
|
|
*
|
|
* p_rtable: list of RTEs that will become the rangetable of the query.
|
|
* Note that neither relname nor refname of these entries are necessarily
|
|
* unique; searching the rtable by name is a bad idea.
|
|
*
|
|
* p_joinexprs: list of JoinExpr nodes associated with p_rtable entries.
|
|
* This is one-for-one with p_rtable, but contains NULLs for non-join
|
|
* RTEs, and may be shorter than p_rtable if the last RTE(s) aren't joins.
|
|
*
|
|
* p_joinlist: list of join items (RangeTblRef and JoinExpr nodes) that
|
|
* will become the fromlist of the query's top-level FromExpr node.
|
|
*
|
|
* p_relnamespace: list of RTEs that represents the current namespace for
|
|
* table lookup, ie, those RTEs that are accessible by qualified names.
|
|
* This may be just a subset of the rtable + joinlist, and/or may contain
|
|
* entries that are not yet added to the main joinlist.
|
|
*
|
|
* p_varnamespace: list of RTEs that represents the current namespace for
|
|
* column lookup, ie, those RTEs that are accessible by unqualified names.
|
|
* This is different from p_relnamespace because a JOIN without an alias does
|
|
* not hide the contained tables (so they must still be in p_relnamespace)
|
|
* but it does hide their columns (unqualified references to the columns must
|
|
* refer to the JOIN, not the member tables). Other special RTEs such as
|
|
* NEW/OLD for rules may also appear in just one of these lists.
|
|
*
|
|
* p_ctenamespace: list of CommonTableExprs (WITH items) that are visible
|
|
* at the moment. This is different from p_relnamespace because you have
|
|
* to make an RTE before you can access a CTE.
|
|
*
|
|
* p_future_ctes: list of CommonTableExprs (WITH items) that are not yet
|
|
* visible due to scope rules. This is used to help improve error messages.
|
|
*
|
|
* p_parent_cte: CommonTableExpr that immediately contains the current query,
|
|
* if any.
|
|
*
|
|
* p_windowdefs: list of WindowDefs representing WINDOW and OVER clauses.
|
|
* We collect these while transforming expressions and then transform them
|
|
* afterwards (so that any resjunk tlist items needed for the sort/group
|
|
* clauses end up at the end of the query tlist). A WindowDef's location in
|
|
* this list, counting from 1, is the winref number to use to reference it.
|
|
*/
|
|
struct ParseState {
|
|
struct ParseState* parentParseState; /* stack link */
|
|
const char* p_sourcetext; /* source text, or NULL if not available */
|
|
List* p_rtable; /* range table so far */
|
|
List* p_joinexprs; /* JoinExprs for RTE_JOIN p_rtable entries */
|
|
List* p_joinlist; /* join items so far (will become FromExpr
|
|
node's fromlist) */
|
|
List* p_relnamespace; /* current namespace for relations */
|
|
List* p_varnamespace; /* current namespace for columns */
|
|
bool p_lateral_active; /* p_lateral_only items visible? */
|
|
List* p_ctenamespace; /* current namespace for common table exprs */
|
|
List* p_future_ctes; /* common table exprs not yet in namespace */
|
|
CommonTableExpr* p_parent_cte; /* this query's containing CTE */
|
|
List* p_windowdefs; /* raw representations of window clauses */
|
|
ParseExprKind p_expr_kind; /* what kind of expression we're parsing */
|
|
List* p_rawdefaultlist; /* raw default list */
|
|
int p_next_resno; /* next targetlist resno to assign */
|
|
List* p_locking_clause; /* raw FOR UPDATE/FOR SHARE info */
|
|
Node* p_value_substitute; /* what to replace VALUE with, if any */
|
|
|
|
/* Flags telling about things found in the query: */
|
|
bool p_hasAggs;
|
|
bool p_hasWindowFuncs;
|
|
bool p_hasSubLinks;
|
|
bool p_hasModifyingCTE;
|
|
bool p_is_insert;
|
|
bool p_locked_from_parent;
|
|
bool p_resolve_unknowns; /* resolve unknown-type SELECT outputs as type text */
|
|
bool p_hasSynonyms;
|
|
Relation p_target_relation;
|
|
RangeTblEntry* p_target_rangetblentry;
|
|
bool p_is_case_when;
|
|
|
|
/*
|
|
* used for start with...connect by rewrite
|
|
*/
|
|
bool p_addStartInfo;
|
|
List *p_start_info;
|
|
int sw_subquery_idx; /* given unname-subquery unique name when sw rewrite */
|
|
SelectStmt *p_sw_selectstmt;
|
|
List *sw_fromClause;
|
|
WithClause *origin_with;
|
|
bool p_hasStartWith;
|
|
bool p_has_ignore; /* whether SQL has ignore hint */
|
|
|
|
/*
|
|
* Optional hook functions for parser callbacks. These are null unless
|
|
* set up by the caller of make_parsestate.
|
|
*/
|
|
PreParseColumnRefHook p_pre_columnref_hook;
|
|
PostParseColumnRefHook p_post_columnref_hook;
|
|
PreParseColumnRefHook p_bind_variable_columnref_hook;
|
|
PreParseColumnRefHook p_bind_describe_hook;
|
|
ParseParamRefHook p_paramref_hook;
|
|
CoerceParamHook p_coerce_param_hook;
|
|
CreateProcOperatorHook p_create_proc_operator_hook;
|
|
CreateProcInsertrHook p_create_proc_insert_hook;
|
|
void* p_ref_hook_state; /* common passthrough link for above */
|
|
void* p_cl_hook_state; /* cl related state - SQLFunctionParseInfoPtr */
|
|
List* p_target_list;
|
|
void* p_bind_hook_state;
|
|
void* p_describeco_hook_state;
|
|
|
|
/*
|
|
* star flag info
|
|
*
|
|
* create table t1(a int, b int);
|
|
* create table t2(a int, b int);
|
|
*
|
|
* For query: select * from t1
|
|
* star_start = 1;
|
|
* star_end = 2;
|
|
* star_only = 1;
|
|
*
|
|
* For query: select t1.*, t2.* from t1, t2
|
|
* star_start = 1, 3;
|
|
* star_end = 2, 4;
|
|
* star_only = -1, -1;
|
|
*/
|
|
List* p_star_start;
|
|
List* p_star_end;
|
|
List* p_star_only;
|
|
|
|
/*
|
|
* The p_is_in_insert will indicate the sub link is under one top insert statement.
|
|
* When p_is_in_insert is true, then we will check if sub link include foreign table,
|
|
* If foreign is found, we will set top level insert ParseState's p_is_foreignTbl_exist to true.
|
|
* Finially, we will set p_is_td_compatible_truncation to true if the td_compatible_truncation guc
|
|
* parameter is on, no foreign table involved in this insert statement.
|
|
*/
|
|
bool p_is_foreignTbl_exist; /* make there is foreign table founded. */
|
|
bool p_is_in_insert; /* mark the subquery is under one insert statement. */
|
|
bool p_is_td_compatible_truncation; /* mark the auto truncation for insert statement is enabled. */
|
|
TdTruncCastStatus tdTruncCastStatus; /* Auto truncation Cast added, only used for stmt in stored procedure or
|
|
prepare stmt. */
|
|
bool isAliasReplace; /* Mark if permit replace. */
|
|
|
|
/*
|
|
* Fields for transform "(+)" to outerjoin
|
|
*/
|
|
bool ignoreplus; /*
|
|
* Whether ignore "(+)" during transform stmt? False is default,
|
|
* report error when found "(+)". Only true when transform WhereClause
|
|
* in SelectStmt.
|
|
*/
|
|
|
|
bool use_level; /* When selecting a column with the same name in an RTE list, whether to consider the
|
|
* priority of RTE.
|
|
* The priority refers to the index of RTE in the list. The smaller the index value, the
|
|
* higher the priority.
|
|
*/
|
|
|
|
PlusJoinRTEInfo* p_plusjoin_rte_info; /* The RTE info while processing "(+)" */
|
|
};
|
|
|
|
/* An element of p_relnamespace or p_varnamespace */
|
|
typedef struct ParseNamespaceItem
|
|
{
|
|
RangeTblEntry *p_rte; /* The relation's rangetable entry */
|
|
bool p_lateral_only; /* Is only visible to LATERAL expressions? */
|
|
bool p_lateral_ok; /* If so, does join type allow use? */
|
|
} ParseNamespaceItem;
|
|
|
|
/* Support for parser_errposition_callback function */
|
|
typedef struct ParseCallbackState {
|
|
ParseState* pstate;
|
|
int location;
|
|
#ifndef FRONTEND
|
|
ErrorContextCallback errcontext;
|
|
#endif
|
|
} ParseCallbackState;
|
|
|
|
extern ParseState* make_parsestate(ParseState* parentParseState);
|
|
extern void free_parsestate(ParseState* pstate);
|
|
extern int parser_errposition(ParseState* pstate, int location);
|
|
|
|
extern void setup_parser_errposition_callback(ParseCallbackState* pcbstate, ParseState* pstate, int location);
|
|
extern void cancel_parser_errposition_callback(ParseCallbackState* pcbstate);
|
|
|
|
extern Var* make_var(ParseState* pstate, RangeTblEntry* rte, int attrno, int location);
|
|
extern Var* ts_make_var(ParseState* pstate, RangeTblEntry* rte, int attrno, int location);
|
|
extern Oid transformArrayType(Oid* arrayType, int32* arrayTypmod);
|
|
extern ArrayRef* transformArraySubscripts(ParseState* pstate, Node* arrayBase, Oid arrayType, Oid elementType,
|
|
int32 arrayTypMod, List* indirection, Node* assignFrom);
|
|
extern Const* make_const(ParseState* pstate, Value* value, int location);
|
|
|
|
#endif /* PARSE_NODE_H */
|