pg_query 2.0.0 → 2.0.1

data/ext/pg_query/include/parser/parse_oper.h

@@ -0,0 +1,67 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_oper.h
+ *		handle operator things for parser
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_oper.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_OPER_H
+#define PARSE_OPER_H
+
+#include "access/htup.h"
+#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
+
+
+typedef HeapTuple Operator;
+
+/* Routines to look up an operator given name and exact input type(s) */
+extern Oid	LookupOperName(ParseState *pstate, List *opername,
+						   Oid oprleft, Oid oprright,
+						   bool noError, int location);
+extern Oid	LookupOperWithArgs(ObjectWithArgs *oper, bool noError);
+
+/* Routines to find operators matching a name and given input types */
+/* NB: the selected operator may require coercion of the input types! */
+extern Operator oper(ParseState *pstate, List *op, Oid arg1, Oid arg2,
+					 bool noError, int location);
+extern Operator right_oper(ParseState *pstate, List *op, Oid arg,
+						   bool noError, int location);
+extern Operator left_oper(ParseState *pstate, List *op, Oid arg,
+						  bool noError, int location);
+
+/* Routines to find operators that DO NOT require coercion --- ie, their */
+/* input types are either exactly as given, or binary-compatible */
+extern Operator compatible_oper(ParseState *pstate, List *op,
+								Oid arg1, Oid arg2,
+								bool noError, int location);
+
+/* currently no need for compatible_left_oper/compatible_right_oper */
+
+/* Routines for identifying "<", "=", ">" operators for a type */
+extern void get_sort_group_operators(Oid argtype,
+									 bool needLT, bool needEQ, bool needGT,
+									 Oid *ltOpr, Oid *eqOpr, Oid *gtOpr,
+									 bool *isHashable);
+
+/* Convenience routines for common calls on the above */
+extern Oid	compatible_oper_opid(List *op, Oid arg1, Oid arg2, bool noError);
+
+/* Extract operator OID or underlying-function OID from an Operator tuple */
+extern Oid	oprid(Operator op);
+extern Oid	oprfuncid(Operator op);
+
+/* Build expression tree for an operator invocation */
+extern Expr *make_op(ParseState *pstate, List *opname,
+					 Node *ltree, Node *rtree, Node *last_srf, int location);
+extern Expr *make_scalar_array_op(ParseState *pstate, List *opname,
+								  bool useOr,
+								  Node *ltree, Node *rtree, int location);
+
+#endif							/* PARSE_OPER_H */

data/ext/pg_query/include/parser/parse_relation.h

@@ -0,0 +1,123 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_relation.h
+ *	  prototypes for parse_relation.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_relation.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_RELATION_H
+#define PARSE_RELATION_H
+
+#include "parser/parse_node.h"
+
+
+extern ParseNamespaceItem *refnameNamespaceItem(ParseState *pstate,
+												const char *schemaname,
+												const char *refname,
+												int location,
+												int *sublevels_up);
+extern CommonTableExpr *scanNameSpaceForCTE(ParseState *pstate,
+											const char *refname,
+											Index *ctelevelsup);
+extern bool scanNameSpaceForENR(ParseState *pstate, const char *refname);
+extern void checkNameSpaceConflicts(ParseState *pstate, List *namespace1,
+									List *namespace2);
+extern ParseNamespaceItem *GetNSItemByRangeTablePosn(ParseState *pstate,
+													 int varno,
+													 int sublevels_up);
+extern RangeTblEntry *GetRTEByRangeTablePosn(ParseState *pstate,
+											 int varno,
+											 int sublevels_up);
+extern CommonTableExpr *GetCTEForRTE(ParseState *pstate, RangeTblEntry *rte,
+									 int rtelevelsup);
+extern Node *scanNSItemForColumn(ParseState *pstate, ParseNamespaceItem *nsitem,
+								 int sublevels_up, const char *colname,
+								 int location);
+extern Node *colNameToVar(ParseState *pstate, const char *colname, bool localonly,
+						  int location);
+extern void markVarForSelectPriv(ParseState *pstate, Var *var,
+								 RangeTblEntry *rte);
+extern Relation parserOpenTable(ParseState *pstate, const RangeVar *relation,
+								int lockmode);
+extern ParseNamespaceItem *addRangeTableEntry(ParseState *pstate,
+											  RangeVar *relation,
+											  Alias *alias,
+											  bool inh,
+											  bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForRelation(ParseState *pstate,
+														 Relation rel,
+														 int lockmode,
+														 Alias *alias,
+														 bool inh,
+														 bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForSubquery(ParseState *pstate,
+														 Query *subquery,
+														 Alias *alias,
+														 bool lateral,
+														 bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForFunction(ParseState *pstate,
+														 List *funcnames,
+														 List *funcexprs,
+														 List *coldeflists,
+														 RangeFunction *rangefunc,
+														 bool lateral,
+														 bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForValues(ParseState *pstate,
+													   List *exprs,
+													   List *coltypes,
+													   List *coltypmods,
+													   List *colcollations,
+													   Alias *alias,
+													   bool lateral,
+													   bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForTableFunc(ParseState *pstate,
+														  TableFunc *tf,
+														  Alias *alias,
+														  bool lateral,
+														  bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForJoin(ParseState *pstate,
+													 List *colnames,
+													 ParseNamespaceColumn *nscolumns,
+													 JoinType jointype,
+													 int nummergedcols,
+													 List *aliasvars,
+													 List *leftcols,
+													 List *rightcols,
+													 Alias *alias,
+													 bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForCTE(ParseState *pstate,
+													CommonTableExpr *cte,
+													Index levelsup,
+													RangeVar *rv,
+													bool inFromCl);
+extern ParseNamespaceItem *addRangeTableEntryForENR(ParseState *pstate,
+													RangeVar *rv,
+													bool inFromCl);
+extern bool isLockedRefname(ParseState *pstate, const char *refname);
+extern void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem,
+							 bool addToJoinList,
+							 bool addToRelNameSpace, bool addToVarNameSpace);
+extern void errorMissingRTE(ParseState *pstate, RangeVar *relation) pg_attribute_noreturn();
+extern void errorMissingColumn(ParseState *pstate,
+							   const char *relname, const char *colname, int location) pg_attribute_noreturn();
+extern void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up,
+					  int location, bool include_dropped,
+					  List **colnames, List **colvars);
+extern List *expandNSItemVars(ParseNamespaceItem *nsitem,
+							  int sublevels_up, int location,
+							  List **colnames);
+extern List *expandNSItemAttrs(ParseState *pstate, ParseNamespaceItem *nsitem,
+							   int sublevels_up, int location);
+extern int	attnameAttNum(Relation rd, const char *attname, bool sysColOK);
+extern const NameData *attnumAttName(Relation rd, int attid);
+extern Oid	attnumTypeId(Relation rd, int attid);
+extern Oid	attnumCollationId(Relation rd, int attid);
+extern bool isQueryUsingTempRelation(Query *query);
+
+#endif							/* PARSE_RELATION_H */

data/ext/pg_query/include/parser/parse_target.h

@@ -0,0 +1,46 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_target.h
+ *	  handle target lists
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_target.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_TARGET_H
+#define PARSE_TARGET_H
+
+#include "parser/parse_node.h"
+
+
+extern List *transformTargetList(ParseState *pstate, List *targetlist,
+								 ParseExprKind exprKind);
+extern List *transformExpressionList(ParseState *pstate, List *exprlist,
+									 ParseExprKind exprKind, bool allowDefault);
+extern void resolveTargetListUnknowns(ParseState *pstate, List *targetlist);
+extern void markTargetListOrigins(ParseState *pstate, List *targetlist);
+extern TargetEntry *transformTargetEntry(ParseState *pstate,
+										 Node *node, Node *expr, ParseExprKind exprKind,
+										 char *colname, bool resjunk);
+extern Expr *transformAssignedExpr(ParseState *pstate, Expr *expr,
+								   ParseExprKind exprKind,
+								   const char *colname,
+								   int attrno,
+								   List *indirection,
+								   int location);
+extern void updateTargetListEntry(ParseState *pstate, TargetEntry *tle,
+								  char *colname, int attrno,
+								  List *indirection,
+								  int location);
+extern List *checkInsertTargets(ParseState *pstate, List *cols,
+								List **attrnos);
+extern TupleDesc expandRecordVariable(ParseState *pstate, Var *var,
+									  int levelsup);
+extern char *FigureColname(Node *node);
+extern char *FigureIndexColname(Node *node);
+
+#endif							/* PARSE_TARGET_H */

data/ext/pg_query/include/parser/parse_type.h

@@ -0,0 +1,60 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_type.h
+ *		handle type operations for parser
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_type.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_TYPE_H
+#define PARSE_TYPE_H
+
+#include "access/htup.h"
+#include "parser/parse_node.h"
+
+
+typedef HeapTuple Type;
+
+extern Type LookupTypeName(ParseState *pstate, const TypeName *typeName,
+						   int32 *typmod_p, bool missing_ok);
+extern Type LookupTypeNameExtended(ParseState *pstate,
+								   const TypeName *typeName, int32 *typmod_p,
+								   bool temp_ok, bool missing_ok);
+extern Oid	LookupTypeNameOid(ParseState *pstate, const TypeName *typeName,
+							  bool missing_ok);
+extern Type typenameType(ParseState *pstate, const TypeName *typeName,
+						 int32 *typmod_p);
+extern Oid	typenameTypeId(ParseState *pstate, const TypeName *typeName);
+extern void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName,
+								 Oid *typeid_p, int32 *typmod_p);
+
+extern char *TypeNameToString(const TypeName *typeName);
+extern char *TypeNameListToString(List *typenames);
+
+extern Oid	LookupCollation(ParseState *pstate, List *collnames, int location);
+extern Oid	GetColumnDefCollation(ParseState *pstate, ColumnDef *coldef, Oid typeOid);
+
+extern Type typeidType(Oid id);
+
+extern Oid	typeTypeId(Type tp);
+extern int16 typeLen(Type t);
+extern bool typeByVal(Type t);
+extern char *typeTypeName(Type t);
+extern Oid	typeTypeRelid(Type typ);
+extern Oid	typeTypeCollation(Type typ);
+extern Datum stringTypeDatum(Type tp, char *string, int32 atttypmod);
+
+extern Oid	typeidTypeRelid(Oid type_id);
+extern Oid	typeOrDomainTypeRelid(Oid type_id);
+
+extern TypeName *typeStringToTypeName(const char *str);
+extern void parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok);
+
+/* true if typeid is composite, or domain over composite, but not RECORD */
+#define ISCOMPLEX(typeid) (typeOrDomainTypeRelid(typeid) != InvalidOid)
+
+#endif							/* PARSE_TYPE_H */

data/ext/pg_query/include/parser/parser.h

@@ -0,0 +1,41 @@
+/*-------------------------------------------------------------------------
+ *
+ * parser.h
+ *		Definitions for the "raw" parser (flex and bison phases only)
+ *
+ * This is the external API for the raw lexing/parsing functions.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parser.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "nodes/parsenodes.h"
+
+
+typedef enum
+{
+	BACKSLASH_QUOTE_OFF,
+	BACKSLASH_QUOTE_ON,
+	BACKSLASH_QUOTE_SAFE_ENCODING
+}			BackslashQuoteType;
+
+/* GUC variables in scan.l (every one of these is a bad idea :-() */
+extern __thread  int backslash_quote;
+extern __thread  bool escape_string_warning;
+extern PGDLLIMPORT __thread  bool standard_conforming_strings;
+
+
+/* Primary entry point for the raw parsing functions */
+extern List *raw_parser(const char *str);
+
+/* Utility functions exported by gram.y (perhaps these should be elsewhere) */
+extern List *SystemFuncName(char *name);
+extern TypeName *SystemTypeName(char *name);
+
+#endif							/* PARSER_H */

data/ext/pg_query/include/parser/parsetree.h

@@ -0,0 +1,61 @@
+/*-------------------------------------------------------------------------
+ *
+ * parsetree.h
+ *	  Routines to access various components and subcomponents of
+ *	  parse trees.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parsetree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSETREE_H
+#define PARSETREE_H
+
+#include "nodes/parsenodes.h"
+
+
+/* ----------------
+ *		range table operations
+ * ----------------
+ */
+
+/*
+ *		rt_fetch
+ *
+ * NB: this will crash and burn if handed an out-of-range RT index
+ */
+#define rt_fetch(rangetable_index, rangetable) \
+	((RangeTblEntry *) list_nth(rangetable, (rangetable_index)-1))
+
+/*
+ * Given an RTE and an attribute number, return the appropriate
+ * variable name or alias for that attribute of that RTE.
+ */
+extern char *get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum);
+
+/*
+ * Check whether an attribute of an RTE has been dropped
+ */
+extern bool get_rte_attribute_is_dropped(RangeTblEntry *rte,
+										 AttrNumber attnum);
+
+
+/* ----------------
+ *		target list operations
+ * ----------------
+ */
+
+extern TargetEntry *get_tle_by_resno(List *tlist, AttrNumber resno);
+
+/* ----------------
+ *		FOR UPDATE/SHARE info
+ * ----------------
+ */
+
+extern RowMarkClause *get_parse_rowmark(Query *qry, Index rtindex);
+
+#endif							/* PARSETREE_H */

data/ext/pg_query/include/parser/scanner.h

@@ -0,0 +1,152 @@
+/*-------------------------------------------------------------------------
+ *
+ * scanner.h
+ *		API for the core scanner (flex machine)
+ *
+ * The core scanner is also used by PL/pgSQL, so we provide a public API
+ * for it.  However, the rest of the backend is only expected to use the
+ * higher-level API provided by parser.h.
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/scanner.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef SCANNER_H
+#define SCANNER_H
+
+#include "common/keywords.h"
+
+/*
+ * The scanner returns extra data about scanned tokens in this union type.
+ * Note that this is a subset of the fields used in YYSTYPE of the bison
+ * parsers built atop the scanner.
+ */
+typedef union core_YYSTYPE
+{
+	int			ival;			/* for integer literals */
+	char	   *str;			/* for identifiers and non-integer literals */
+	const char *keyword;		/* canonical spelling of keywords */
+} core_YYSTYPE;
+
+/*
+ * We track token locations in terms of byte offsets from the start of the
+ * source string, not the column number/line number representation that
+ * bison uses by default.  Also, to minimize overhead we track only one
+ * location (usually the first token location) for each construct, not
+ * the beginning and ending locations as bison does by default.  It's
+ * therefore sufficient to make YYLTYPE an int.
+ */
+#define YYLTYPE  int
+
+/*
+ * Another important component of the scanner's API is the token code numbers.
+ * However, those are not defined in this file, because bison insists on
+ * defining them for itself.  The token codes used by the core scanner are
+ * the ASCII characters plus these:
+ *	%token <str>	IDENT UIDENT FCONST SCONST USCONST BCONST XCONST Op
+ *	%token <ival>	ICONST PARAM
+ *	%token			TYPECAST DOT_DOT COLON_EQUALS EQUALS_GREATER
+ *	%token			LESS_EQUALS GREATER_EQUALS NOT_EQUALS
+ * The above token definitions *must* be the first ones declared in any
+ * bison parser built atop this scanner, so that they will have consistent
+ * numbers assigned to them (specifically, IDENT = 258 and so on).
+ */
+
+/*
+ * The YY_EXTRA data that a flex scanner allows us to pass around.
+ * Private state needed by the core scanner goes here.  Note that the actual
+ * yy_extra struct may be larger and have this as its first component, thus
+ * allowing the calling parser to keep some fields of its own in YY_EXTRA.
+ */
+typedef struct core_yy_extra_type
+{
+	/*
+	 * The string the scanner is physically scanning.  We keep this mainly so
+	 * that we can cheaply compute the offset of the current token (yytext).
+	 */
+	char	   *scanbuf;
+	Size		scanbuflen;
+
+	/*
+	 * The keyword list to use, and the associated grammar token codes.
+	 */
+	const ScanKeywordList *keywordlist;
+	const uint16 *keyword_tokens;
+
+	/*
+	 * Scanner settings to use.  These are initialized from the corresponding
+	 * GUC variables by scanner_init().  Callers can modify them after
+	 * scanner_init() if they don't want the scanner's behavior to follow the
+	 * prevailing GUC settings.
+	 */
+	int			backslash_quote;
+	bool		escape_string_warning;
+	bool		standard_conforming_strings;
+
+	/*
+	 * literalbuf is used to accumulate literal values when multiple rules are
+	 * needed to parse a single literal.  Call startlit() to reset buffer to
+	 * empty, addlit() to add text.  NOTE: the string in literalbuf is NOT
+	 * necessarily null-terminated, but there always IS room to add a trailing
+	 * null at offset literallen.  We store a null only when we need it.
+	 */
+	char	   *literalbuf;		/* palloc'd expandable buffer */
+	int			literallen;		/* actual current string length */
+	int			literalalloc;	/* current allocated buffer size */
+
+	/*
+	 * Random assorted scanner state.
+	 */
+	int			state_before_str_stop;	/* start cond. before end quote */
+	int			xcdepth;		/* depth of nesting in slash-star comments */
+	char	   *dolqstart;		/* current $foo$ quote start string */
+	YYLTYPE		save_yylloc;	/* one-element stack for PUSH_YYLLOC() */
+
+	/* first part of UTF16 surrogate pair for Unicode escapes */
+	int32		utf16_first_part;
+
+	/* state variables for literal-lexing warnings */
+	bool		warn_on_first_escape;
+	bool		saw_non_ascii;
+
+	int yyllocend;
+} core_yy_extra_type;
+
+/*
+ * The type of yyscanner is opaque outside scan.l.
+ */
+typedef void *core_yyscan_t;
+
+/* Support for scanner_errposition_callback function */
+typedef struct ScannerCallbackState
+{
+	core_yyscan_t yyscanner;
+	int			location;
+	ErrorContextCallback errcallback;
+} ScannerCallbackState;
+
+
+/* Constant data exported from parser/scan.l */
+extern PGDLLIMPORT const uint16 ScanKeywordTokens[];
+
+/* Entry points in parser/scan.l */
+extern core_yyscan_t scanner_init(const char *str,
+								  core_yy_extra_type *yyext,
+								  const ScanKeywordList *keywordlist,
+								  const uint16 *keyword_tokens);
+extern void scanner_finish(core_yyscan_t yyscanner);
+extern int	core_yylex(core_YYSTYPE *lvalp, YYLTYPE *llocp,
+					   core_yyscan_t yyscanner);
+extern int	scanner_errposition(int location, core_yyscan_t yyscanner);
+extern void setup_scanner_errposition_callback(ScannerCallbackState *scbstate,
+											   core_yyscan_t yyscanner,
+											   int location);
+extern void cancel_scanner_errposition_callback(ScannerCallbackState *scbstate);
+extern void scanner_yyerror(const char *message, core_yyscan_t yyscanner) pg_attribute_noreturn();
+
+#endif							/* SCANNER_H */