init

2026-04-07 13:35:22 +08:00
commit 0120fa9ce3
1530 changed files with 424864 additions and 0 deletions
--- a/pg_include/parser/analyze.h
+++ b/pg_include/parser/analyze.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * analyze.h
+ *		parse analysis for optimizable statements
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/analyze.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ANALYZE_H
+#define ANALYZE_H
+
+#include "parser/parse_node.h"
+
+/* Hook for plugins to get control at end of parse analysis */
+typedef void (*post_parse_analyze_hook_type) (ParseState *pstate,
+														  Query *query);
+extern PGDLLIMPORT post_parse_analyze_hook_type post_parse_analyze_hook;
+
+
+extern Query *parse_analyze(Node *parseTree, const char *sourceText,
+			  Oid *paramTypes, int numParams);
+extern Query *parse_analyze_varparams(Node *parseTree, const char *sourceText,
+						Oid **paramTypes, int *numParams);
+
+extern Query *parse_sub_analyze(Node *parseTree, ParseState *parentParseState,
+				  CommonTableExpr *parentCTE,
+				  bool locked_from_parent);
+
+extern Query *transformTopLevelStmt(ParseState *pstate, Node *parseTree);
+extern Query *transformStmt(ParseState *pstate, Node *parseTree);
+
+extern bool analyze_requires_snapshot(Node *parseTree);
+
+extern void CheckSelectLocking(Query *qry);
+extern void applyLockingClause(Query *qry, Index rtindex,
+				   bool forUpdate, bool noWait, bool pushedDown);
+
+#endif   /* ANALYZE_H */
--- a/pg_include/parser/gram.h
+++ b/pg_include/parser/gram.h
@@ -0,0 +1,527 @@
+
+/* A Bison parser, made by GNU Bison 2.4.1.  */
+
+/* Skeleton interface for Bison's Yacc-like parsers in C
+   
+      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+   
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     IDENT = 258,
+     FCONST = 259,
+     SCONST = 260,
+     BCONST = 261,
+     XCONST = 262,
+     Op = 263,
+     ICONST = 264,
+     PARAM = 265,
+     TYPECAST = 266,
+     DOT_DOT = 267,
+     COLON_EQUALS = 268,
+     ABORT_P = 269,
+     ABSOLUTE_P = 270,
+     ACCESS = 271,
+     ACTION = 272,
+     ADD_P = 273,
+     ADMIN = 274,
+     AFTER = 275,
+     AGGREGATE = 276,
+     ALL = 277,
+     ALSO = 278,
+     ALTER = 279,
+     ALWAYS = 280,
+     ANALYSE = 281,
+     ANALYZE = 282,
+     AND = 283,
+     ANY = 284,
+     ARRAY = 285,
+     AS = 286,
+     ASC = 287,
+     ASSERTION = 288,
+     ASSIGNMENT = 289,
+     ASYMMETRIC = 290,
+     AT = 291,
+     ATTRIBUTE = 292,
+     AUTHORIZATION = 293,
+     BACKWARD = 294,
+     BEFORE = 295,
+     BEGIN_P = 296,
+     BETWEEN = 297,
+     BIGINT = 298,
+     BINARY = 299,
+     BIT = 300,
+     BOOLEAN_P = 301,
+     BOTH = 302,
+     BY = 303,
+     CACHE = 304,
+     CALLED = 305,
+     CASCADE = 306,
+     CASCADED = 307,
+     CASE = 308,
+     CAST = 309,
+     CATALOG_P = 310,
+     CHAIN = 311,
+     CHAR_P = 312,
+     CHARACTER = 313,
+     CHARACTERISTICS = 314,
+     CHECK = 315,
+     CHECKPOINT = 316,
+     CLASS = 317,
+     CLOSE = 318,
+     CLUSTER = 319,
+     COALESCE = 320,
+     COLLATE = 321,
+     COLLATION = 322,
+     COLUMN = 323,
+     COMMENT = 324,
+     COMMENTS = 325,
+     COMMIT = 326,
+     COMMITTED = 327,
+     CONCURRENTLY = 328,
+     CONFIGURATION = 329,
+     CONNECTION = 330,
+     CONSTRAINT = 331,
+     CONSTRAINTS = 332,
+     CONTENT_P = 333,
+     CONTINUE_P = 334,
+     CONVERSION_P = 335,
+     COPY = 336,
+     COST = 337,
+     CREATE = 338,
+     CROSS = 339,
+     CSV = 340,
+     CURRENT_P = 341,
+     CURRENT_CATALOG = 342,
+     CURRENT_DATE = 343,
+     CURRENT_ROLE = 344,
+     CURRENT_SCHEMA = 345,
+     CURRENT_TIME = 346,
+     CURRENT_TIMESTAMP = 347,
+     CURRENT_USER = 348,
+     CURSOR = 349,
+     CYCLE = 350,
+     DATA_P = 351,
+     DATABASE = 352,
+     DAY_P = 353,
+     DEALLOCATE = 354,
+     DEC = 355,
+     DECIMAL_P = 356,
+     DECLARE = 357,
+     DEFAULT = 358,
+     DEFAULTS = 359,
+     DEFERRABLE = 360,
+     DEFERRED = 361,
+     DEFINER = 362,
+     DELETE_P = 363,
+     DELIMITER = 364,
+     DELIMITERS = 365,
+     DESC = 366,
+     DICTIONARY = 367,
+     DISABLE_P = 368,
+     DISCARD = 369,
+     DISTINCT = 370,
+     DO = 371,
+     DOCUMENT_P = 372,
+     DOMAIN_P = 373,
+     DOUBLE_P = 374,
+     DROP = 375,
+     EACH = 376,
+     ELSE = 377,
+     ENABLE_P = 378,
+     ENCODING = 379,
+     ENCRYPTED = 380,
+     END_P = 381,
+     ENUM_P = 382,
+     ESCAPE = 383,
+     EXCEPT = 384,
+     EXCLUDE = 385,
+     EXCLUDING = 386,
+     EXCLUSIVE = 387,
+     EXECUTE = 388,
+     EXISTS = 389,
+     EXPLAIN = 390,
+     EXTENSION = 391,
+     EXTERNAL = 392,
+     EXTRACT = 393,
+     FALSE_P = 394,
+     FAMILY = 395,
+     FETCH = 396,
+     FIRST_P = 397,
+     FLOAT_P = 398,
+     FOLLOWING = 399,
+     FOR = 400,
+     FORCE = 401,
+     FOREIGN = 402,
+     FORWARD = 403,
+     FREEZE = 404,
+     FROM = 405,
+     FULL = 406,
+     FUNCTION = 407,
+     FUNCTIONS = 408,
+     GLOBAL = 409,
+     GRANT = 410,
+     GRANTED = 411,
+     GREATEST = 412,
+     GROUP_P = 413,
+     HANDLER = 414,
+     HAVING = 415,
+     HEADER_P = 416,
+     HOLD = 417,
+     HOUR_P = 418,
+     IDENTITY_P = 419,
+     IF_P = 420,
+     ILIKE = 421,
+     IMMEDIATE = 422,
+     IMMUTABLE = 423,
+     IMPLICIT_P = 424,
+     IN_P = 425,
+     INCLUDING = 426,
+     INCREMENT = 427,
+     INDEX = 428,
+     INDEXES = 429,
+     INHERIT = 430,
+     INHERITS = 431,
+     INITIALLY = 432,
+     INLINE_P = 433,
+     INNER_P = 434,
+     INOUT = 435,
+     INPUT_P = 436,
+     INSENSITIVE = 437,
+     INSERT = 438,
+     INSTEAD = 439,
+     INT_P = 440,
+     INTEGER = 441,
+     INTERSECT = 442,
+     INTERVAL = 443,
+     INTO = 444,
+     INVOKER = 445,
+     IS = 446,
+     ISNULL = 447,
+     ISOLATION = 448,
+     JOIN = 449,
+     KEY = 450,
+     LABEL = 451,
+     LANGUAGE = 452,
+     LARGE_P = 453,
+     LAST_P = 454,
+     LC_COLLATE_P = 455,
+     LC_CTYPE_P = 456,
+     LEADING = 457,
+     LEAKPROOF = 458,
+     LEAST = 459,
+     LEFT = 460,
+     LEVEL = 461,
+     LIKE = 462,
+     LIMIT = 463,
+     LISTEN = 464,
+     LOAD = 465,
+     LOCAL = 466,
+     LOCALTIME = 467,
+     LOCALTIMESTAMP = 468,
+     LOCATION = 469,
+     LOCK_P = 470,
+     MAPPING = 471,
+     MATCH = 472,
+     MAXVALUE = 473,
+     MINUTE_P = 474,
+     MINVALUE = 475,
+     MODE = 476,
+     MONTH_P = 477,
+     MOVE = 478,
+     NAME_P = 479,
+     NAMES = 480,
+     NATIONAL = 481,
+     NATURAL = 482,
+     NCHAR = 483,
+     NEXT = 484,
+     NO = 485,
+     NONE = 486,
+     NOT = 487,
+     NOTHING = 488,
+     NOTIFY = 489,
+     NOTNULL = 490,
+     NOWAIT = 491,
+     NULL_P = 492,
+     NULLIF = 493,
+     NULLS_P = 494,
+     NUMERIC = 495,
+     OBJECT_P = 496,
+     OF = 497,
+     OFF = 498,
+     OFFSET = 499,
+     OIDS = 500,
+     ON = 501,
+     ONLY = 502,
+     OPERATOR = 503,
+     OPTION = 504,
+     OPTIONS = 505,
+     OR = 506,
+     ORDER = 507,
+     OUT_P = 508,
+     OUTER_P = 509,
+     OVER = 510,
+     OVERLAPS = 511,
+     OVERLAY = 512,
+     OWNED = 513,
+     OWNER = 514,
+     PARSER = 515,
+     PARTIAL = 516,
+     PARTITION = 517,
+     PASSING = 518,
+     PASSWORD = 519,
+     PLACING = 520,
+     PLANS = 521,
+     POSITION = 522,
+     PRECEDING = 523,
+     PRECISION = 524,
+     PRESERVE = 525,
+     PREPARE = 526,
+     PREPARED = 527,
+     PRIMARY = 528,
+     PRIOR = 529,
+     PRIVILEGES = 530,
+     PROCEDURAL = 531,
+     PROCEDURE = 532,
+     QUOTE = 533,
+     RANGE = 534,
+     READ = 535,
+     REAL = 536,
+     REASSIGN = 537,
+     RECHECK = 538,
+     RECURSIVE = 539,
+     REF = 540,
+     REFERENCES = 541,
+     REINDEX = 542,
+     RELATIVE_P = 543,
+     RELEASE = 544,
+     RENAME = 545,
+     REPEATABLE = 546,
+     REPLACE = 547,
+     REPLICA = 548,
+     RESET = 549,
+     RESTART = 550,
+     RESTRICT = 551,
+     RETURNING = 552,
+     RETURNS = 553,
+     REVOKE = 554,
+     RIGHT = 555,
+     ROLE = 556,
+     ROLLBACK = 557,
+     ROW = 558,
+     ROWS = 559,
+     RULE = 560,
+     SAVEPOINT = 561,
+     SCHEMA = 562,
+     SCROLL = 563,
+     SEARCH = 564,
+     SECOND_P = 565,
+     SECURITY = 566,
+     SELECT = 567,
+     SEQUENCE = 568,
+     SEQUENCES = 569,
+     SERIALIZABLE = 570,
+     SERVER = 571,
+     SESSION = 572,
+     SESSION_USER = 573,
+     SET = 574,
+     SETOF = 575,
+     SHARE = 576,
+     SHOW = 577,
+     SIMILAR = 578,
+     SIMPLE = 579,
+     SMALLINT = 580,
+     SNAPSHOT = 581,
+     SOME = 582,
+     STABLE = 583,
+     STANDALONE_P = 584,
+     START = 585,
+     STATEMENT = 586,
+     STATISTICS = 587,
+     STDIN = 588,
+     STDOUT = 589,
+     STORAGE = 590,
+     STRICT_P = 591,
+     STRIP_P = 592,
+     SUBSTRING = 593,
+     SYMMETRIC = 594,
+     SYSID = 595,
+     SYSTEM_P = 596,
+     TABLE = 597,
+     TABLES = 598,
+     TABLESPACE = 599,
+     TEMP = 600,
+     TEMPLATE = 601,
+     TEMPORARY = 602,
+     TEXT_P = 603,
+     THEN = 604,
+     TIME = 605,
+     TIMESTAMP = 606,
+     TO = 607,
+     TRAILING = 608,
+     TRANSACTION = 609,
+     TREAT = 610,
+     TRIGGER = 611,
+     TRIM = 612,
+     TRUE_P = 613,
+     TRUNCATE = 614,
+     TRUSTED = 615,
+     TYPE_P = 616,
+     TYPES_P = 617,
+     UNBOUNDED = 618,
+     UNCOMMITTED = 619,
+     UNENCRYPTED = 620,
+     UNION = 621,
+     UNIQUE = 622,
+     UNKNOWN = 623,
+     UNLISTEN = 624,
+     UNLOGGED = 625,
+     UNTIL = 626,
+     UPDATE = 627,
+     USER = 628,
+     USING = 629,
+     VACUUM = 630,
+     VALID = 631,
+     VALIDATE = 632,
+     VALIDATOR = 633,
+     VALUE_P = 634,
+     VALUES = 635,
+     VARCHAR = 636,
+     VARIADIC = 637,
+     VARYING = 638,
+     VERBOSE = 639,
+     VERSION_P = 640,
+     VIEW = 641,
+     VOLATILE = 642,
+     WHEN = 643,
+     WHERE = 644,
+     WHITESPACE_P = 645,
+     WINDOW = 646,
+     WITH = 647,
+     WITHOUT = 648,
+     WORK = 649,
+     WRAPPER = 650,
+     WRITE = 651,
+     XML_P = 652,
+     XMLATTRIBUTES = 653,
+     XMLCONCAT = 654,
+     XMLELEMENT = 655,
+     XMLEXISTS = 656,
+     XMLFOREST = 657,
+     XMLPARSE = 658,
+     XMLPI = 659,
+     XMLROOT = 660,
+     XMLSERIALIZE = 661,
+     YEAR_P = 662,
+     YES_P = 663,
+     ZONE = 664,
+     NULLS_FIRST = 665,
+     NULLS_LAST = 666,
+     WITH_TIME = 667,
+     POSTFIXOP = 668,
+     UMINUS = 669
+   };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+{
+
+/* Line 1676 of yacc.c  */
+#line 160 "gram.y"
+
+	core_YYSTYPE		core_yystype;
+	/* these fields must match core_YYSTYPE: */
+	int					ival;
+	char				*str;
+	const char			*keyword;
+
+	char				chr;
+	bool				boolean;
+	JoinType			jtype;
+	DropBehavior		dbehavior;
+	OnCommitAction		oncommit;
+	List				*list;
+	Node				*node;
+	Value				*value;
+	ObjectType			objtype;
+	TypeName			*typnam;
+	FunctionParameter   *fun_param;
+	FunctionParameterMode fun_param_mode;
+	FuncWithArgs		*funwithargs;
+	DefElem				*defelt;
+	SortBy				*sortby;
+	WindowDef			*windef;
+	JoinExpr			*jexpr;
+	IndexElem			*ielem;
+	Alias				*alias;
+	RangeVar			*range;
+	IntoClause			*into;
+	WithClause			*with;
+	A_Indices			*aind;
+	ResTarget			*target;
+	struct PrivTarget	*privtarget;
+	AccessPriv			*accesspriv;
+	InsertStmt			*istmt;
+	VariableSetStmt		*vsetstmt;
+
+
+
+/* Line 1676 of yacc.c  */
+#line 505 "gram.h"
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
--- a/pg_include/parser/gramparse.h
+++ b/pg_include/parser/gramparse.h
@@ -0,0 +1,146 @@
+// /*-------------------------------------------------------------------------
+//  *
+//  * gramparse.h
+//  *		Shared definitions for the "raw" parser (flex and bison phases only)
+//  *
+//  * NOTE: this file is only meant to be included in the core parsing files,
+//  * ie, parser.c, gram.y, scan.l, and keywords.c.  Definitions that are needed
+//  * outside the core parser should be in parser.h.
+//  *
+//  *
+//  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+//  * Portions Copyright (c) 1994, Regents of the University of California
+//  *
+//  * src/include/parser/gramparse.h
+//  *
+//  *-------------------------------------------------------------------------
+//  */
+
+// #ifndef GRAMPARSE_H
+// #define GRAMPARSE_H
+
+// #include "nodes/parsenodes.h"
+// #include "parser/scanner.h"
+
+// /*
+//  * NB: include gram.h only AFTER including scanner.h, because scanner.h
+//  * is what #defines YYLTYPE.
+//  */
+// #include "parser/gram.h"
+
+// /*
+//  * The YY_EXTRA data that a flex scanner allows us to pass around.	Private
+//  * state needed for raw parsing/lexing goes here.
+//  */
+// typedef struct base_yy_extra_type
+// {
+// 	/*
+// 	 * Fields used by the core scanner.
+// 	 */
+// 	core_yy_extra_type core_yy_extra;
+
+// 	/*
+// 	 * State variables for base_yylex().
+// 	 */
+// 	bool		have_lookahead; /* is lookahead info valid? */
+// 	int			lookahead_token;	/* one-token lookahead */
+// 	core_YYSTYPE lookahead_yylval;		/* yylval for lookahead token */
+// 	YYLTYPE		lookahead_yylloc;		/* yylloc for lookahead token */
+
+// 	/*
+// 	 * State variables that belong to the grammar.
+// 	 */
+// 	List	   *parsetree;		/* final parse result is delivered here */
+// } base_yy_extra_type;
+
+// /*
+//  * In principle we should use yyget_extra() to fetch the yyextra field
+//  * from a yyscanner struct.  However, flex always puts that field first,
+//  * and this is sufficiently performance-critical to make it seem worth
+//  * cheating a bit to use an inline macro.
+//  */
+// #define pg_yyget_extra(yyscanner) (*((base_yy_extra_type **) (yyscanner)))
+
+
+// /* from parser.c */
+// extern int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp,
+// 		   core_yyscan_t yyscanner);
+
+// /* from gram.y */
+// extern void parser_init(base_yy_extra_type *yyext);
+// extern int	base_yyparse(core_yyscan_t yyscanner);
+
+// #endif   /* GRAMPARSE_H */
+/*-------------------------------------------------------------------------
+ *
+ * gramparse.h
+ *		Shared definitions for the "raw" parser (flex and bison phases only)
+ *
+ * NOTE: this file is only meant to be included in the core parsing files,
+ * ie, parser.c, gram.y, scan.l, and keywords.c.  Definitions that are needed
+ * outside the core parser should be in parser.h.
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/gramparse.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef GRAMPARSE_H
+#define GRAMPARSE_H
+
+#include "nodes/parsenodes.h"
+#include "parser/scanner.h"
+
+/*
+ * NB: include gram.h only AFTER including scanner.h, because scanner.h
+ * is what #defines YYLTYPE.
+ */
+#include "parser/gram.h"
+
+/*
+ * The YY_EXTRA data that a flex scanner allows us to pass around.  Private
+ * state needed for raw parsing/lexing goes here.
+ */
+typedef struct base_yy_extra_type
+{
+	/*
+	 * Fields used by the core scanner.
+	 */
+	core_yy_extra_type core_yy_extra;
+
+	/*
+	 * State variables for base_yylex().
+	 */
+	bool		have_lookahead; /* is lookahead info valid? */
+	int			lookahead_token;	/* one-token lookahead */
+	core_YYSTYPE lookahead_yylval;		/* yylval for lookahead token */
+	YYLTYPE		lookahead_yylloc;		/* yylloc for lookahead token */
+
+	/*
+	 * State variables that belong to the grammar.
+	 */
+	List	   *parsetree;		/* final parse result is delivered here */
+} base_yy_extra_type;
+
+/*
+ * In principle we should use yyget_extra() to fetch the yyextra field
+ * from a yyscanner struct.  However, flex always puts that field first,
+ * and this is sufficiently performance-critical to make it seem worth
+ * cheating a bit to use an inline macro.
+ */
+#define pg_yyget_extra(yyscanner) (*((base_yy_extra_type **) (yyscanner)))
+
+
+/* from parser.c */
+extern int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp,
+		   core_yyscan_t yyscanner);
+
+/* from gram.y */
+extern void parser_init(base_yy_extra_type *yyext);
+extern int	base_yyparse(core_yyscan_t yyscanner);
+
+#endif   /* GRAMPARSE_H */
--- a/pg_include/parser/keywords.h
+++ b/pg_include/parser/keywords.h
@@ -0,0 +1,38 @@
+/*-------------------------------------------------------------------------
+ *
+ * keywords.h
+ *	  lexical token lookup for key words in PostgreSQL
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/keywords.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef KEYWORDS_H
+#define KEYWORDS_H
+
+/* Keyword categories --- should match lists in gram.y */
+#define UNRESERVED_KEYWORD		0
+#define COL_NAME_KEYWORD		1
+#define TYPE_FUNC_NAME_KEYWORD	2
+#define RESERVED_KEYWORD		3
+
+
+typedef struct ScanKeyword
+{
+	const char *name;			/* in lower case */
+	int16		value;			/* grammar's token code */
+	int16		category;		/* see codes above */
+} ScanKeyword;
+
+extern PGDLLIMPORT const ScanKeyword ScanKeywords[];
+extern PGDLLIMPORT const int NumScanKeywords;
+
+extern const ScanKeyword *ScanKeywordLookup(const char *text,
+				  const ScanKeyword *keywords,
+				  int num_keywords);
+
+#endif   /* KEYWORDS_H */
--- a/pg_include/parser/kwlist.h
+++ b/pg_include/parser/kwlist.h
@@ -0,0 +1,424 @@
+/*-------------------------------------------------------------------------
+ *
+ * kwlist.h
+ *
+ * The keyword list is kept in its own source file for possible use by
+ * automatic tools.  The exact representation of a keyword is determined
+ * by the PG_KEYWORD macro, which is not defined in this file; it can
+ * be defined by the caller for special purposes.
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/include/parser/kwlist.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/* there is deliberately not an #ifndef KWLIST_H here */
+
+/*
+ * List of keyword (name, token-value, category) entries.
+ *
+ * !!WARNING!!: This list must be sorted by ASCII name, because binary
+ *		 search is used to locate entries.
+ */
+
+/* name, value, category */
+PG_KEYWORD("abort", ABORT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("absolute", ABSOLUTE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("access", ACCESS, UNRESERVED_KEYWORD)
+PG_KEYWORD("action", ACTION, UNRESERVED_KEYWORD)
+PG_KEYWORD("add", ADD_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("admin", ADMIN, UNRESERVED_KEYWORD)
+PG_KEYWORD("after", AFTER, UNRESERVED_KEYWORD)
+PG_KEYWORD("aggregate", AGGREGATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("all", ALL, RESERVED_KEYWORD)
+PG_KEYWORD("also", ALSO, UNRESERVED_KEYWORD)
+PG_KEYWORD("alter", ALTER, UNRESERVED_KEYWORD)
+PG_KEYWORD("always", ALWAYS, UNRESERVED_KEYWORD)
+PG_KEYWORD("analyse", ANALYSE, RESERVED_KEYWORD)		/* British spelling */
+PG_KEYWORD("analyze", ANALYZE, RESERVED_KEYWORD)
+PG_KEYWORD("and", AND, RESERVED_KEYWORD)
+PG_KEYWORD("any", ANY, RESERVED_KEYWORD)
+PG_KEYWORD("array", ARRAY, RESERVED_KEYWORD)
+PG_KEYWORD("as", AS, RESERVED_KEYWORD)
+PG_KEYWORD("asc", ASC, RESERVED_KEYWORD)
+PG_KEYWORD("assertion", ASSERTION, UNRESERVED_KEYWORD)
+PG_KEYWORD("assignment", ASSIGNMENT, UNRESERVED_KEYWORD)
+PG_KEYWORD("asymmetric", ASYMMETRIC, RESERVED_KEYWORD)
+PG_KEYWORD("at", AT, UNRESERVED_KEYWORD)
+PG_KEYWORD("attribute", ATTRIBUTE, UNRESERVED_KEYWORD)
+PG_KEYWORD("authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("backward", BACKWARD, UNRESERVED_KEYWORD)
+PG_KEYWORD("before", BEFORE, UNRESERVED_KEYWORD)
+PG_KEYWORD("begin", BEGIN_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("between", BETWEEN, COL_NAME_KEYWORD)
+PG_KEYWORD("bigint", BIGINT, COL_NAME_KEYWORD)
+PG_KEYWORD("binary", BINARY, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("bit", BIT, COL_NAME_KEYWORD)
+PG_KEYWORD("boolean", BOOLEAN_P, COL_NAME_KEYWORD)
+PG_KEYWORD("both", BOTH, RESERVED_KEYWORD)
+PG_KEYWORD("by", BY, UNRESERVED_KEYWORD)
+PG_KEYWORD("cache", CACHE, UNRESERVED_KEYWORD)
+PG_KEYWORD("called", CALLED, UNRESERVED_KEYWORD)
+PG_KEYWORD("cascade", CASCADE, UNRESERVED_KEYWORD)
+PG_KEYWORD("cascaded", CASCADED, UNRESERVED_KEYWORD)
+PG_KEYWORD("case", CASE, RESERVED_KEYWORD)
+PG_KEYWORD("cast", CAST, RESERVED_KEYWORD)
+PG_KEYWORD("catalog", CATALOG_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("chain", CHAIN, UNRESERVED_KEYWORD)
+PG_KEYWORD("char", CHAR_P, COL_NAME_KEYWORD)
+PG_KEYWORD("character", CHARACTER, COL_NAME_KEYWORD)
+PG_KEYWORD("characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD)
+PG_KEYWORD("check", CHECK, RESERVED_KEYWORD)
+PG_KEYWORD("checkpoint", CHECKPOINT, UNRESERVED_KEYWORD)
+PG_KEYWORD("class", CLASS, UNRESERVED_KEYWORD)
+PG_KEYWORD("close", CLOSE, UNRESERVED_KEYWORD)
+PG_KEYWORD("cluster", CLUSTER, UNRESERVED_KEYWORD)
+PG_KEYWORD("coalesce", COALESCE, COL_NAME_KEYWORD)
+PG_KEYWORD("collate", COLLATE, RESERVED_KEYWORD)
+PG_KEYWORD("collation", COLLATION, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("column", COLUMN, RESERVED_KEYWORD)
+PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD)
+PG_KEYWORD("comments", COMMENTS, UNRESERVED_KEYWORD)
+PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD)
+PG_KEYWORD("committed", COMMITTED, UNRESERVED_KEYWORD)
+PG_KEYWORD("concurrently", CONCURRENTLY, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("configuration", CONFIGURATION, UNRESERVED_KEYWORD)
+PG_KEYWORD("connection", CONNECTION, UNRESERVED_KEYWORD)
+PG_KEYWORD("constraint", CONSTRAINT, RESERVED_KEYWORD)
+PG_KEYWORD("constraints", CONSTRAINTS, UNRESERVED_KEYWORD)
+PG_KEYWORD("content", CONTENT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("continue", CONTINUE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("conversion", CONVERSION_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("copy", COPY, UNRESERVED_KEYWORD)
+PG_KEYWORD("cost", COST, UNRESERVED_KEYWORD)
+PG_KEYWORD("create", CREATE, RESERVED_KEYWORD)
+PG_KEYWORD("cross", CROSS, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("csv", CSV, UNRESERVED_KEYWORD)
+PG_KEYWORD("current", CURRENT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("current_catalog", CURRENT_CATALOG, RESERVED_KEYWORD)
+PG_KEYWORD("current_date", CURRENT_DATE, RESERVED_KEYWORD)
+PG_KEYWORD("current_role", CURRENT_ROLE, RESERVED_KEYWORD)
+PG_KEYWORD("current_schema", CURRENT_SCHEMA, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("current_time", CURRENT_TIME, RESERVED_KEYWORD)
+PG_KEYWORD("current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD)
+PG_KEYWORD("current_user", CURRENT_USER, RESERVED_KEYWORD)
+PG_KEYWORD("cursor", CURSOR, UNRESERVED_KEYWORD)
+PG_KEYWORD("cycle", CYCLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("data", DATA_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("database", DATABASE, UNRESERVED_KEYWORD)
+PG_KEYWORD("day", DAY_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("deallocate", DEALLOCATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("dec", DEC, COL_NAME_KEYWORD)
+PG_KEYWORD("decimal", DECIMAL_P, COL_NAME_KEYWORD)
+PG_KEYWORD("declare", DECLARE, UNRESERVED_KEYWORD)
+PG_KEYWORD("default", DEFAULT, RESERVED_KEYWORD)
+PG_KEYWORD("defaults", DEFAULTS, UNRESERVED_KEYWORD)
+PG_KEYWORD("deferrable", DEFERRABLE, RESERVED_KEYWORD)
+PG_KEYWORD("deferred", DEFERRED, UNRESERVED_KEYWORD)
+PG_KEYWORD("definer", DEFINER, UNRESERVED_KEYWORD)
+PG_KEYWORD("delete", DELETE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("delimiter", DELIMITER, UNRESERVED_KEYWORD)
+PG_KEYWORD("delimiters", DELIMITERS, UNRESERVED_KEYWORD)
+PG_KEYWORD("desc", DESC, RESERVED_KEYWORD)
+PG_KEYWORD("dictionary", DICTIONARY, UNRESERVED_KEYWORD)
+PG_KEYWORD("disable", DISABLE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("discard", DISCARD, UNRESERVED_KEYWORD)
+PG_KEYWORD("distinct", DISTINCT, RESERVED_KEYWORD)
+PG_KEYWORD("do", DO, RESERVED_KEYWORD)
+PG_KEYWORD("document", DOCUMENT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("domain", DOMAIN_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("double", DOUBLE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("drop", DROP, UNRESERVED_KEYWORD)
+PG_KEYWORD("each", EACH, UNRESERVED_KEYWORD)
+PG_KEYWORD("else", ELSE, RESERVED_KEYWORD)
+PG_KEYWORD("enable", ENABLE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("encoding", ENCODING, UNRESERVED_KEYWORD)
+PG_KEYWORD("encrypted", ENCRYPTED, UNRESERVED_KEYWORD)
+PG_KEYWORD("end", END_P, RESERVED_KEYWORD)
+PG_KEYWORD("enum", ENUM_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("escape", ESCAPE, UNRESERVED_KEYWORD)
+PG_KEYWORD("except", EXCEPT, RESERVED_KEYWORD)
+PG_KEYWORD("exclude", EXCLUDE, UNRESERVED_KEYWORD)
+PG_KEYWORD("excluding", EXCLUDING, UNRESERVED_KEYWORD)
+PG_KEYWORD("exclusive", EXCLUSIVE, UNRESERVED_KEYWORD)
+PG_KEYWORD("execute", EXECUTE, UNRESERVED_KEYWORD)
+PG_KEYWORD("exists", EXISTS, COL_NAME_KEYWORD)
+PG_KEYWORD("explain", EXPLAIN, UNRESERVED_KEYWORD)
+PG_KEYWORD("extension", EXTENSION, UNRESERVED_KEYWORD)
+PG_KEYWORD("external", EXTERNAL, UNRESERVED_KEYWORD)
+PG_KEYWORD("extract", EXTRACT, COL_NAME_KEYWORD)
+PG_KEYWORD("false", FALSE_P, RESERVED_KEYWORD)
+PG_KEYWORD("family", FAMILY, UNRESERVED_KEYWORD)
+PG_KEYWORD("fetch", FETCH, RESERVED_KEYWORD)
+PG_KEYWORD("first", FIRST_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("float", FLOAT_P, COL_NAME_KEYWORD)
+PG_KEYWORD("following", FOLLOWING, UNRESERVED_KEYWORD)
+PG_KEYWORD("for", FOR, RESERVED_KEYWORD)
+PG_KEYWORD("force", FORCE, UNRESERVED_KEYWORD)
+PG_KEYWORD("foreign", FOREIGN, RESERVED_KEYWORD)
+PG_KEYWORD("forward", FORWARD, UNRESERVED_KEYWORD)
+PG_KEYWORD("freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("from", FROM, RESERVED_KEYWORD)
+PG_KEYWORD("full", FULL, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("function", FUNCTION, UNRESERVED_KEYWORD)
+PG_KEYWORD("functions", FUNCTIONS, UNRESERVED_KEYWORD)
+PG_KEYWORD("global", GLOBAL, UNRESERVED_KEYWORD)
+PG_KEYWORD("grant", GRANT, RESERVED_KEYWORD)
+PG_KEYWORD("granted", GRANTED, UNRESERVED_KEYWORD)
+PG_KEYWORD("greatest", GREATEST, COL_NAME_KEYWORD)
+PG_KEYWORD("group", GROUP_P, RESERVED_KEYWORD)
+PG_KEYWORD("handler", HANDLER, UNRESERVED_KEYWORD)
+PG_KEYWORD("having", HAVING, RESERVED_KEYWORD)
+PG_KEYWORD("header", HEADER_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("hold", HOLD, UNRESERVED_KEYWORD)
+PG_KEYWORD("hour", HOUR_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("identity", IDENTITY_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("if", IF_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("immediate", IMMEDIATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("immutable", IMMUTABLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("implicit", IMPLICIT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("in", IN_P, RESERVED_KEYWORD)
+PG_KEYWORD("including", INCLUDING, UNRESERVED_KEYWORD)
+PG_KEYWORD("increment", INCREMENT, UNRESERVED_KEYWORD)
+PG_KEYWORD("index", INDEX, UNRESERVED_KEYWORD)
+PG_KEYWORD("indexes", INDEXES, UNRESERVED_KEYWORD)
+PG_KEYWORD("inherit", INHERIT, UNRESERVED_KEYWORD)
+PG_KEYWORD("inherits", INHERITS, UNRESERVED_KEYWORD)
+PG_KEYWORD("initially", INITIALLY, RESERVED_KEYWORD)
+PG_KEYWORD("inline", INLINE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("inner", INNER_P, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("inout", INOUT, COL_NAME_KEYWORD)
+PG_KEYWORD("input", INPUT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("insensitive", INSENSITIVE, UNRESERVED_KEYWORD)
+PG_KEYWORD("insert", INSERT, UNRESERVED_KEYWORD)
+PG_KEYWORD("instead", INSTEAD, UNRESERVED_KEYWORD)
+PG_KEYWORD("int", INT_P, COL_NAME_KEYWORD)
+PG_KEYWORD("integer", INTEGER, COL_NAME_KEYWORD)
+PG_KEYWORD("intersect", INTERSECT, RESERVED_KEYWORD)
+PG_KEYWORD("interval", INTERVAL, COL_NAME_KEYWORD)
+PG_KEYWORD("into", INTO, RESERVED_KEYWORD)
+PG_KEYWORD("invoker", INVOKER, UNRESERVED_KEYWORD)
+PG_KEYWORD("is", IS, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("isolation", ISOLATION, UNRESERVED_KEYWORD)
+PG_KEYWORD("join", JOIN, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("key", KEY, UNRESERVED_KEYWORD)
+PG_KEYWORD("label", LABEL, UNRESERVED_KEYWORD)
+PG_KEYWORD("language", LANGUAGE, UNRESERVED_KEYWORD)
+PG_KEYWORD("large", LARGE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("last", LAST_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("lc_collate", LC_COLLATE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("lc_ctype", LC_CTYPE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("leading", LEADING, RESERVED_KEYWORD)
+PG_KEYWORD("leakproof", LEAKPROOF, UNRESERVED_KEYWORD)
+PG_KEYWORD("least", LEAST, COL_NAME_KEYWORD)
+PG_KEYWORD("left", LEFT, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("level", LEVEL, UNRESERVED_KEYWORD)
+PG_KEYWORD("like", LIKE, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("limit", LIMIT, RESERVED_KEYWORD)
+PG_KEYWORD("listen", LISTEN, UNRESERVED_KEYWORD)
+PG_KEYWORD("load", LOAD, UNRESERVED_KEYWORD)
+PG_KEYWORD("local", LOCAL, UNRESERVED_KEYWORD)
+PG_KEYWORD("localtime", LOCALTIME, RESERVED_KEYWORD)
+PG_KEYWORD("localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD)
+PG_KEYWORD("location", LOCATION, UNRESERVED_KEYWORD)
+PG_KEYWORD("lock", LOCK_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("mapping", MAPPING, UNRESERVED_KEYWORD)
+PG_KEYWORD("match", MATCH, UNRESERVED_KEYWORD)
+PG_KEYWORD("maxvalue", MAXVALUE, UNRESERVED_KEYWORD)
+PG_KEYWORD("minute", MINUTE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("minvalue", MINVALUE, UNRESERVED_KEYWORD)
+PG_KEYWORD("mode", MODE, UNRESERVED_KEYWORD)
+PG_KEYWORD("month", MONTH_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("move", MOVE, UNRESERVED_KEYWORD)
+PG_KEYWORD("name", NAME_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("names", NAMES, UNRESERVED_KEYWORD)
+PG_KEYWORD("national", NATIONAL, COL_NAME_KEYWORD)
+PG_KEYWORD("natural", NATURAL, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("nchar", NCHAR, COL_NAME_KEYWORD)
+PG_KEYWORD("next", NEXT, UNRESERVED_KEYWORD)
+PG_KEYWORD("no", NO, UNRESERVED_KEYWORD)
+PG_KEYWORD("none", NONE, COL_NAME_KEYWORD)
+PG_KEYWORD("not", NOT, RESERVED_KEYWORD)
+PG_KEYWORD("nothing", NOTHING, UNRESERVED_KEYWORD)
+PG_KEYWORD("notify", NOTIFY, UNRESERVED_KEYWORD)
+PG_KEYWORD("notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("nowait", NOWAIT, UNRESERVED_KEYWORD)
+PG_KEYWORD("null", NULL_P, RESERVED_KEYWORD)
+PG_KEYWORD("nullif", NULLIF, COL_NAME_KEYWORD)
+PG_KEYWORD("nulls", NULLS_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("numeric", NUMERIC, COL_NAME_KEYWORD)
+PG_KEYWORD("object", OBJECT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("of", OF, UNRESERVED_KEYWORD)
+PG_KEYWORD("off", OFF, UNRESERVED_KEYWORD)
+PG_KEYWORD("offset", OFFSET, RESERVED_KEYWORD)
+PG_KEYWORD("oids", OIDS, UNRESERVED_KEYWORD)
+PG_KEYWORD("on", ON, RESERVED_KEYWORD)
+PG_KEYWORD("only", ONLY, RESERVED_KEYWORD)
+PG_KEYWORD("operator", OPERATOR, UNRESERVED_KEYWORD)
+PG_KEYWORD("option", OPTION, UNRESERVED_KEYWORD)
+PG_KEYWORD("options", OPTIONS, UNRESERVED_KEYWORD)
+PG_KEYWORD("or", OR, RESERVED_KEYWORD)
+PG_KEYWORD("order", ORDER, RESERVED_KEYWORD)
+PG_KEYWORD("out", OUT_P, COL_NAME_KEYWORD)
+PG_KEYWORD("outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("over", OVER, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("overlay", OVERLAY, COL_NAME_KEYWORD)
+PG_KEYWORD("owned", OWNED, UNRESERVED_KEYWORD)
+PG_KEYWORD("owner", OWNER, UNRESERVED_KEYWORD)
+PG_KEYWORD("parser", PARSER, UNRESERVED_KEYWORD)
+PG_KEYWORD("partial", PARTIAL, UNRESERVED_KEYWORD)
+PG_KEYWORD("partition", PARTITION, UNRESERVED_KEYWORD)
+PG_KEYWORD("passing", PASSING, UNRESERVED_KEYWORD)
+PG_KEYWORD("password", PASSWORD, UNRESERVED_KEYWORD)
+PG_KEYWORD("placing", PLACING, RESERVED_KEYWORD)
+PG_KEYWORD("plans", PLANS, UNRESERVED_KEYWORD)
+PG_KEYWORD("position", POSITION, COL_NAME_KEYWORD)
+PG_KEYWORD("preceding", PRECEDING, UNRESERVED_KEYWORD)
+PG_KEYWORD("precision", PRECISION, COL_NAME_KEYWORD)
+PG_KEYWORD("prepare", PREPARE, UNRESERVED_KEYWORD)
+PG_KEYWORD("prepared", PREPARED, UNRESERVED_KEYWORD)
+PG_KEYWORD("preserve", PRESERVE, UNRESERVED_KEYWORD)
+PG_KEYWORD("primary", PRIMARY, RESERVED_KEYWORD)
+PG_KEYWORD("prior", PRIOR, UNRESERVED_KEYWORD)
+PG_KEYWORD("privileges", PRIVILEGES, UNRESERVED_KEYWORD)
+PG_KEYWORD("procedural", PROCEDURAL, UNRESERVED_KEYWORD)
+PG_KEYWORD("procedure", PROCEDURE, UNRESERVED_KEYWORD)
+PG_KEYWORD("quote", QUOTE, UNRESERVED_KEYWORD)
+PG_KEYWORD("range", RANGE, UNRESERVED_KEYWORD)
+PG_KEYWORD("read", READ, UNRESERVED_KEYWORD)
+PG_KEYWORD("real", REAL, COL_NAME_KEYWORD)
+PG_KEYWORD("reassign", REASSIGN, UNRESERVED_KEYWORD)
+PG_KEYWORD("recheck", RECHECK, UNRESERVED_KEYWORD)
+PG_KEYWORD("recursive", RECURSIVE, UNRESERVED_KEYWORD)
+PG_KEYWORD("ref", REF, UNRESERVED_KEYWORD)
+PG_KEYWORD("references", REFERENCES, RESERVED_KEYWORD)
+PG_KEYWORD("reindex", REINDEX, UNRESERVED_KEYWORD)
+PG_KEYWORD("relative", RELATIVE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("release", RELEASE, UNRESERVED_KEYWORD)
+PG_KEYWORD("rename", RENAME, UNRESERVED_KEYWORD)
+PG_KEYWORD("repeatable", REPEATABLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("replace", REPLACE, UNRESERVED_KEYWORD)
+PG_KEYWORD("replica", REPLICA, UNRESERVED_KEYWORD)
+PG_KEYWORD("reset", RESET, UNRESERVED_KEYWORD)
+PG_KEYWORD("restart", RESTART, UNRESERVED_KEYWORD)
+PG_KEYWORD("restrict", RESTRICT, UNRESERVED_KEYWORD)
+PG_KEYWORD("returning", RETURNING, RESERVED_KEYWORD)
+PG_KEYWORD("returns", RETURNS, UNRESERVED_KEYWORD)
+PG_KEYWORD("revoke", REVOKE, UNRESERVED_KEYWORD)
+PG_KEYWORD("right", RIGHT, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("role", ROLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("rollback", ROLLBACK, UNRESERVED_KEYWORD)
+PG_KEYWORD("row", ROW, COL_NAME_KEYWORD)
+PG_KEYWORD("rows", ROWS, UNRESERVED_KEYWORD)
+PG_KEYWORD("rule", RULE, UNRESERVED_KEYWORD)
+PG_KEYWORD("savepoint", SAVEPOINT, UNRESERVED_KEYWORD)
+PG_KEYWORD("schema", SCHEMA, UNRESERVED_KEYWORD)
+PG_KEYWORD("scroll", SCROLL, UNRESERVED_KEYWORD)
+PG_KEYWORD("search", SEARCH, UNRESERVED_KEYWORD)
+PG_KEYWORD("second", SECOND_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("security", SECURITY, UNRESERVED_KEYWORD)
+PG_KEYWORD("select", SELECT, RESERVED_KEYWORD)
+PG_KEYWORD("sequence", SEQUENCE, UNRESERVED_KEYWORD)
+PG_KEYWORD("sequences", SEQUENCES, UNRESERVED_KEYWORD)
+PG_KEYWORD("serializable", SERIALIZABLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("server", SERVER, UNRESERVED_KEYWORD)
+PG_KEYWORD("session", SESSION, UNRESERVED_KEYWORD)
+PG_KEYWORD("session_user", SESSION_USER, RESERVED_KEYWORD)
+PG_KEYWORD("set", SET, UNRESERVED_KEYWORD)
+PG_KEYWORD("setof", SETOF, COL_NAME_KEYWORD)
+PG_KEYWORD("share", SHARE, UNRESERVED_KEYWORD)
+PG_KEYWORD("show", SHOW, UNRESERVED_KEYWORD)
+PG_KEYWORD("similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("simple", SIMPLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("smallint", SMALLINT, COL_NAME_KEYWORD)
+PG_KEYWORD("snapshot", SNAPSHOT, UNRESERVED_KEYWORD)
+PG_KEYWORD("some", SOME, RESERVED_KEYWORD)
+PG_KEYWORD("stable", STABLE, UNRESERVED_KEYWORD)
+PG_KEYWORD("standalone", STANDALONE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("start", START, UNRESERVED_KEYWORD)
+PG_KEYWORD("statement", STATEMENT, UNRESERVED_KEYWORD)
+PG_KEYWORD("statistics", STATISTICS, UNRESERVED_KEYWORD)
+PG_KEYWORD("stdin", STDIN, UNRESERVED_KEYWORD)
+PG_KEYWORD("stdout", STDOUT, UNRESERVED_KEYWORD)
+PG_KEYWORD("storage", STORAGE, UNRESERVED_KEYWORD)
+PG_KEYWORD("strict", STRICT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("strip", STRIP_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("substring", SUBSTRING, COL_NAME_KEYWORD)
+PG_KEYWORD("symmetric", SYMMETRIC, RESERVED_KEYWORD)
+PG_KEYWORD("sysid", SYSID, UNRESERVED_KEYWORD)
+PG_KEYWORD("system", SYSTEM_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("table", TABLE, RESERVED_KEYWORD)
+PG_KEYWORD("tables", TABLES, UNRESERVED_KEYWORD)
+PG_KEYWORD("tablespace", TABLESPACE, UNRESERVED_KEYWORD)
+PG_KEYWORD("temp", TEMP, UNRESERVED_KEYWORD)
+PG_KEYWORD("template", TEMPLATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("temporary", TEMPORARY, UNRESERVED_KEYWORD)
+PG_KEYWORD("text", TEXT_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("then", THEN, RESERVED_KEYWORD)
+PG_KEYWORD("time", TIME, COL_NAME_KEYWORD)
+PG_KEYWORD("timestamp", TIMESTAMP, COL_NAME_KEYWORD)
+PG_KEYWORD("to", TO, RESERVED_KEYWORD)
+PG_KEYWORD("trailing", TRAILING, RESERVED_KEYWORD)
+PG_KEYWORD("transaction", TRANSACTION, UNRESERVED_KEYWORD)
+PG_KEYWORD("treat", TREAT, COL_NAME_KEYWORD)
+PG_KEYWORD("trigger", TRIGGER, UNRESERVED_KEYWORD)
+PG_KEYWORD("trim", TRIM, COL_NAME_KEYWORD)
+PG_KEYWORD("true", TRUE_P, RESERVED_KEYWORD)
+PG_KEYWORD("truncate", TRUNCATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("trusted", TRUSTED, UNRESERVED_KEYWORD)
+PG_KEYWORD("type", TYPE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("types", TYPES_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("unbounded", UNBOUNDED, UNRESERVED_KEYWORD)
+PG_KEYWORD("uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD)
+PG_KEYWORD("unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD)
+PG_KEYWORD("union", UNION, RESERVED_KEYWORD)
+PG_KEYWORD("unique", UNIQUE, RESERVED_KEYWORD)
+PG_KEYWORD("unknown", UNKNOWN, UNRESERVED_KEYWORD)
+PG_KEYWORD("unlisten", UNLISTEN, UNRESERVED_KEYWORD)
+PG_KEYWORD("unlogged", UNLOGGED, UNRESERVED_KEYWORD)
+PG_KEYWORD("until", UNTIL, UNRESERVED_KEYWORD)
+PG_KEYWORD("update", UPDATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("user", USER, RESERVED_KEYWORD)
+PG_KEYWORD("using", USING, RESERVED_KEYWORD)
+PG_KEYWORD("vacuum", VACUUM, UNRESERVED_KEYWORD)
+PG_KEYWORD("valid", VALID, UNRESERVED_KEYWORD)
+PG_KEYWORD("validate", VALIDATE, UNRESERVED_KEYWORD)
+PG_KEYWORD("validator", VALIDATOR, UNRESERVED_KEYWORD)
+PG_KEYWORD("value", VALUE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("values", VALUES, COL_NAME_KEYWORD)
+PG_KEYWORD("varchar", VARCHAR, COL_NAME_KEYWORD)
+PG_KEYWORD("variadic", VARIADIC, RESERVED_KEYWORD)
+PG_KEYWORD("varying", VARYING, UNRESERVED_KEYWORD)
+PG_KEYWORD("verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD)
+PG_KEYWORD("version", VERSION_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("view", VIEW, UNRESERVED_KEYWORD)
+PG_KEYWORD("volatile", VOLATILE, UNRESERVED_KEYWORD)
+PG_KEYWORD("when", WHEN, RESERVED_KEYWORD)
+PG_KEYWORD("where", WHERE, RESERVED_KEYWORD)
+PG_KEYWORD("whitespace", WHITESPACE_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("window", WINDOW, RESERVED_KEYWORD)
+PG_KEYWORD("with", WITH, RESERVED_KEYWORD)
+PG_KEYWORD("without", WITHOUT, UNRESERVED_KEYWORD)
+PG_KEYWORD("work", WORK, UNRESERVED_KEYWORD)
+PG_KEYWORD("wrapper", WRAPPER, UNRESERVED_KEYWORD)
+PG_KEYWORD("write", WRITE, UNRESERVED_KEYWORD)
+PG_KEYWORD("xml", XML_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlconcat", XMLCONCAT, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlelement", XMLELEMENT, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlexists", XMLEXISTS, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlforest", XMLFOREST, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlparse", XMLPARSE, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlpi", XMLPI, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlroot", XMLROOT, COL_NAME_KEYWORD)
+PG_KEYWORD("xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD)
+PG_KEYWORD("year", YEAR_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("yes", YES_P, UNRESERVED_KEYWORD)
+PG_KEYWORD("zone", ZONE, UNRESERVED_KEYWORD)
--- a/pg_include/parser/parse_agg.h
+++ b/pg_include/parser/parse_agg.h
@@ -0,0 +1,37 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_agg.h
+ *	  handle aggregates and window functions in parser
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_agg.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_AGG_H
+#define PARSE_AGG_H
+
+#include "parser/parse_node.h"
+
+extern void transformAggregateCall(ParseState *pstate, Aggref *agg,
+					   List *args, List *aggorder,
+					   bool agg_distinct);
+extern void transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
+						WindowDef *windef);
+
+extern void parseCheckAggregates(ParseState *pstate, Query *qry);
+extern void parseCheckWindowFuncs(ParseState *pstate, Query *qry);
+
+extern void build_aggregate_fnexprs(Oid *agg_input_types,
+						int agg_num_inputs,
+						Oid agg_state_type,
+						Oid agg_result_type,
+						Oid agg_input_collation,
+						Oid transfn_oid,
+						Oid finalfn_oid,
+						Expr **transfnexpr,
+						Expr **finalfnexpr);
+
+#endif   /* PARSE_AGG_H */
--- a/pg_include/parser/parse_clause.h
+++ b/pg_include/parser/parse_clause.h
@@ -0,0 +1,47 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_clause.h
+ *	  handle clauses in parser
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_clause.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_CLAUSE_H
+#define PARSE_CLAUSE_H
+
+#include "parser/parse_node.h"
+
+extern void transformFromClause(ParseState *pstate, List *frmList);
+extern int setTargetTable(ParseState *pstate, RangeVar *relation,
+			   bool inh, bool alsoSource, AclMode requiredPerms);
+extern bool interpretInhOption(InhOption inhOpt);
+extern bool interpretOidsOption(List *defList);
+
+extern Node *transformWhereClause(ParseState *pstate, Node *clause,
+					 const char *constructName);
+extern Node *transformLimitClause(ParseState *pstate, Node *clause,
+					 const char *constructName);
+extern List *transformGroupClause(ParseState *pstate, List *grouplist,
+					 List **targetlist, List *sortClause,
+					 bool useSQL99);
+extern List *transformSortClause(ParseState *pstate, List *orderlist,
+					List **targetlist, bool resolveUnknown, bool useSQL99);
+
+extern List *transformWindowDefinitions(ParseState *pstate,
+						   List *windowdefs,
+						   List **targetlist);
+
+extern List *transformDistinctClause(ParseState *pstate,
+						List **targetlist, List *sortClause, bool is_agg);
+extern List *transformDistinctOnClause(ParseState *pstate, List *distinctlist,
+						  List **targetlist, List *sortClause);
+
+extern Index assignSortGroupRef(TargetEntry *tle, List *tlist);
+extern bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList);
+
+#endif   /* PARSE_CLAUSE_H */
--- a/pg_include/parser/parse_coerce.h
+++ b/pg_include/parser/parse_coerce.h
@@ -0,0 +1,90 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_coerce.h
+ *	Routines for type coercion.
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_coerce.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_COERCE_H
+#define PARSE_COERCE_H
+
+#include "parser/parse_node.h"
+
+
+/* Type categories (see TYPCATEGORY_xxx symbols in catalog/pg_type.h) */
+typedef char TYPCATEGORY;
+
+/* Result codes for find_coercion_pathway */
+typedef enum CoercionPathType
+{
+	COERCION_PATH_NONE,			/* failed to find any coercion pathway */
+	COERCION_PATH_FUNC,			/* apply the specified coercion function */
+	COERCION_PATH_RELABELTYPE,	/* binary-compatible cast, no function */
+	COERCION_PATH_ARRAYCOERCE,	/* need an ArrayCoerceExpr node */
+	COERCION_PATH_COERCEVIAIO	/* need a CoerceViaIO node */
+} CoercionPathType;
+
+
+extern bool IsBinaryCoercible(Oid srctype, Oid targettype);
+extern bool IsPreferredType(TYPCATEGORY category, Oid type);
+extern TYPCATEGORY TypeCategory(Oid type);
+
+extern Node *coerce_to_target_type(ParseState *pstate,
+					  Node *expr, Oid exprtype,
+					  Oid targettype, int32 targettypmod,
+					  CoercionContext ccontext,
+					  CoercionForm cformat,
+					  int location);
+extern bool can_coerce_type(int nargs, Oid *input_typeids, Oid *target_typeids,
+				CoercionContext ccontext);
+extern Node *coerce_type(ParseState *pstate, Node *node,
+			Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod,
+			CoercionContext ccontext, CoercionForm cformat, int location);
+extern Node *coerce_to_domain(Node *arg, Oid baseTypeId, int32 baseTypeMod,
+				 Oid typeId,
+				 CoercionForm cformat, int location,
+				 bool hideInputCoercion,
+				 bool lengthCoercionDone);
+
+extern Node *coerce_to_boolean(ParseState *pstate, Node *node,
+				  const char *constructName);
+extern Node *coerce_to_specific_type(ParseState *pstate, Node *node,
+						Oid targetTypeId,
+						const char *constructName);
+
+extern int parser_coercion_errposition(ParseState *pstate,
+							int coerce_location,
+							Node *input_expr);
+
+extern Oid select_common_type(ParseState *pstate, List *exprs,
+				   const char *context, Node **which_expr);
+extern Node *coerce_to_common_type(ParseState *pstate, Node *node,
+					  Oid targetTypeId,
+					  const char *context);
+
+extern bool check_generic_type_consistency(Oid *actual_arg_types,
+							   Oid *declared_arg_types,
+							   int nargs);
+extern Oid enforce_generic_type_consistency(Oid *actual_arg_types,
+								 Oid *declared_arg_types,
+								 int nargs,
+								 Oid rettype,
+								 bool allow_poly);
+extern Oid resolve_generic_type(Oid declared_type,
+					 Oid context_actual_type,
+					 Oid context_declared_type);
+
+extern CoercionPathType find_coercion_pathway(Oid targetTypeId,
+					  Oid sourceTypeId,
+					  CoercionContext ccontext,
+					  Oid *funcid);
+extern CoercionPathType find_typmod_coercion_function(Oid typeId,
+							  Oid *funcid);
+
+#endif   /* PARSE_COERCE_H */
--- a/pg_include/parser/parse_collate.h
+++ b/pg_include/parser/parse_collate.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_collate.h
+ *	Routines for assigning collation information.
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_collate.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_COLLATE_H
+#define PARSE_COLLATE_H
+
+#include "parser/parse_node.h"
+
+extern void assign_query_collations(ParseState *pstate, Query *query);
+
+extern void assign_list_collations(ParseState *pstate, List *exprs);
+
+extern void assign_expr_collations(ParseState *pstate, Node *expr);
+
+extern Oid	select_common_collation(ParseState *pstate, List *exprs, bool none_ok);
+
+#endif   /* PARSE_COLLATE_H */
--- a/pg_include/parser/parse_cte.h
+++ b/pg_include/parser/parse_cte.h
@@ -0,0 +1,24 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_cte.h
+ *	  handle CTEs (common table expressions) in parser
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_cte.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_CTE_H
+#define PARSE_CTE_H
+
+#include "parser/parse_node.h"
+
+extern List *transformWithClause(ParseState *pstate, WithClause *withClause);
+
+extern void analyzeCTETargetList(ParseState *pstate, CommonTableExpr *cte,
+					 List *tlist);
+
+#endif   /* PARSE_CTE_H */
--- a/pg_include/parser/parse_expr.h
+++ b/pg_include/parser/parse_expr.h
@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_expr.h
+ *	  handle expressions in parser
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_expr.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_EXPR_H
+#define PARSE_EXPR_H
+
+#include "parser/parse_node.h"
+
+/* GUC parameters */
+extern bool Transform_null_equals;
+
+extern Node *transformExpr(ParseState *pstate, Node *expr);
+
+#endif   /* PARSE_EXPR_H */
--- a/pg_include/parser/parse_func.h
+++ b/pg_include/parser/parse_func.h
@@ -0,0 +1,85 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_func.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_func.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSER_FUNC_H
+#define PARSER_FUNC_H
+
+#include "catalog/namespace.h"
+#include "parser/parse_node.h"
+
+
+/*
+ *	This structure is used to explore the inheritance hierarchy above
+ *	nodes in the type tree in order to disambiguate among polymorphic
+ *	functions.
+ */
+typedef struct _InhPaths
+{
+	int			nsupers;		/* number of superclasses */
+	Oid			self;			/* this class */
+	Oid		   *supervec;		/* vector of superclasses */
+}	InhPaths;
+
+/* Result codes for func_get_detail */
+typedef enum
+{
+	FUNCDETAIL_NOTFOUND,		/* no matching function */
+	FUNCDETAIL_MULTIPLE,		/* too many matching functions */
+	FUNCDETAIL_NORMAL,			/* found a matching regular function */
+	FUNCDETAIL_AGGREGATE,		/* found a matching aggregate function */
+	FUNCDETAIL_WINDOWFUNC,		/* found a matching window function */
+	FUNCDETAIL_COERCION			/* it's a type coercion request */
+} FuncDetailCode;
+
+
+extern Node *ParseFuncOrColumn(ParseState *pstate,
+				  List *funcname, List *fargs,
+				  List *agg_order, bool agg_star, bool agg_distinct,
+				  bool func_variadic,
+				  WindowDef *over, bool is_column, int location);
+
+extern FuncDetailCode func_get_detail(List *funcname,
+				List *fargs, List *fargnames,
+				int nargs, Oid *argtypes,
+				bool expand_variadic, bool expand_defaults,
+				Oid *funcid, Oid *rettype,
+				bool *retset, int *nvargs, Oid **true_typeids,
+				List **argdefaults);
+
+extern int func_match_argtypes(int nargs,
+					Oid *input_typeids,
+					FuncCandidateList raw_candidates,
+					FuncCandidateList *candidates);
+
+extern FuncCandidateList func_select_candidate(int nargs,
+					  Oid *input_typeids,
+					  FuncCandidateList candidates);
+
+extern void make_fn_arguments(ParseState *pstate,
+				  List *fargs,
+				  Oid *actual_arg_types,
+				  Oid *declared_arg_types);
+
+extern const char *funcname_signature_string(const char *funcname, int nargs,
+						  List *argnames, const Oid *argtypes);
+extern const char *func_signature_string(List *funcname, int nargs,
+					  List *argnames, const Oid *argtypes);
+
+extern Oid LookupFuncName(List *funcname, int nargs, const Oid *argtypes,
+			   bool noError);
+extern Oid LookupFuncNameTypeNames(List *funcname, List *argtypes,
+						bool noError);
+extern Oid LookupAggNameTypeNames(List *aggname, List *argtypes,
+					   bool noError);
+
+#endif   /* PARSE_FUNC_H */
--- a/pg_include/parser/parse_node.h
+++ b/pg_include/parser/parse_node.h
@@ -0,0 +1,153 @@
+/*-------------------------------------------------------------------------
+ *
+ * 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
+ *
+ * src/include/parser/parse_node.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_NODE_H
+#define PARSE_NODE_H
+
+#include "nodes/parsenodes.h"
+#include "utils/relcache.h"
+
+
+/*
+ * 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);
+
+
+/*
+ * 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 */
+	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 */
+	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 */
+	bool		p_hasAggs;
+	bool		p_hasWindowFuncs;
+	bool		p_hasSubLinks;
+	bool		p_hasModifyingCTE;
+	bool		p_is_insert;
+	bool		p_is_update;
+	bool		p_locked_from_parent;
+	Relation	p_target_relation;
+	RangeTblEntry *p_target_rangetblentry;
+
+	/*
+	 * 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;
+	ParseParamRefHook p_paramref_hook;
+	CoerceParamHook p_coerce_param_hook;
+	void	   *p_ref_hook_state;		/* common passthrough link for above */
+};
+
+/* Support for parser_errposition_callback function */
+typedef struct ParseCallbackState
+{
+	ParseState *pstate;
+	int			location;
+	ErrorContextCallback errcontext;
+} 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 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 */
--- a/pg_include/parser/parse_oper.h
+++ b/pg_include/parser/parse_oper.h
@@ -0,0 +1,68 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_oper.h
+ *		handle operator things for parser
+ *
+ *
+ * Portions Copyright (c) 1996-2012, 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 "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 LookupOperNameTypeNames(ParseState *pstate, List *opername,
+						TypeName *oprleft, TypeName *oprright,
+						bool noError, int location);
+
+/* 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, int location);
+extern Expr *make_scalar_array_op(ParseState *pstate, List *opname,
+					 bool useOr,
+					 Node *ltree, Node *rtree, int location);
+
+#endif   /* PARSE_OPER_H */
--- a/pg_include/parser/parse_param.h
+++ b/pg_include/parser/parse_param.h
@@ -0,0 +1,24 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_param.h
+ *	  handle parameters in parser
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_param.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_PARAM_H
+#define PARSE_PARAM_H
+
+#include "parser/parse_node.h"
+
+extern void parse_fixed_parameters(ParseState *pstate,
+					   Oid *paramTypes, int numParams);
+extern void parse_variable_parameters(ParseState *pstate,
+						  Oid **paramTypes, int *numParams);
+extern void check_variable_parameters(ParseState *pstate, Query *query);
+
+#endif   /* PARSE_PARAM_H */
--- a/pg_include/parser/parse_relation.h
+++ b/pg_include/parser/parse_relation.h
@@ -0,0 +1,95 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_relation.h
+ *	  prototypes for parse_relation.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2012, 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 RangeTblEntry *refnameRangeTblEntry(ParseState *pstate,
+					 const char *schemaname,
+					 const char *refname,
+					 int location,
+					 int *sublevels_up);
+extern CommonTableExpr *scanNameSpaceForCTE(ParseState *pstate,
+					const char *refname,
+					Index *ctelevelsup);
+extern void checkNameSpaceConflicts(ParseState *pstate, List *namespace1,
+						List *namespace2);
+extern int RTERangeTablePosn(ParseState *pstate,
+				  RangeTblEntry *rte,
+				  int *sublevels_up);
+extern RangeTblEntry *GetRTEByRangeTablePosn(ParseState *pstate,
+					   int varno,
+					   int sublevels_up);
+extern CommonTableExpr *GetCTEForRTE(ParseState *pstate, RangeTblEntry *rte,
+			 int rtelevelsup);
+extern Node *scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte,
+				 char *colname, int location);
+extern Node *colNameToVar(ParseState *pstate, 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 RangeTblEntry *addRangeTableEntry(ParseState *pstate,
+				   RangeVar *relation,
+				   Alias *alias,
+				   bool inh,
+				   bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForRelation(ParseState *pstate,
+							  Relation rel,
+							  Alias *alias,
+							  bool inh,
+							  bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForSubquery(ParseState *pstate,
+							  Query *subquery,
+							  Alias *alias,
+							  bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForFunction(ParseState *pstate,
+							  char *funcname,
+							  Node *funcexpr,
+							  RangeFunction *rangefunc,
+							  bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForValues(ParseState *pstate,
+							List *exprs,
+							List *collations,
+							Alias *alias,
+							bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForJoin(ParseState *pstate,
+						  List *colnames,
+						  JoinType jointype,
+						  List *aliasvars,
+						  Alias *alias,
+						  bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForCTE(ParseState *pstate,
+						 CommonTableExpr *cte,
+						 Index levelsup,
+						 RangeVar *rv,
+						 bool inFromCl);
+extern bool isLockedRefname(ParseState *pstate, const char *refname);
+extern void addRTEtoQuery(ParseState *pstate, RangeTblEntry *rte,
+			  bool addToJoinList,
+			  bool addToRelNameSpace, bool addToVarNameSpace);
+extern void errorMissingRTE(ParseState *pstate, RangeVar *relation);
+extern void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up,
+		  int location, bool include_dropped,
+		  List **colnames, List **colvars);
+extern List *expandRelAttrs(ParseState *pstate, RangeTblEntry *rte,
+			   int rtindex, int sublevels_up, int location);
+extern int	attnameAttNum(Relation rd, const char *attname, bool sysColOK);
+extern Name attnumAttName(Relation rd, int attid);
+extern Oid	attnumTypeId(Relation rd, int attid);
+extern Oid	attnumCollationId(Relation rd, int attid);
+
+#endif   /* PARSE_RELATION_H */
--- a/pg_include/parser/parse_target.h
+++ b/pg_include/parser/parse_target.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_target.h
+ *	  handle target lists
+ *
+ *
+ * Portions Copyright (c) 1996-2012, 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);
+extern List *transformExpressionList(ParseState *pstate, List *exprlist);
+extern void markTargetListOrigins(ParseState *pstate, List *targetlist);
+extern TargetEntry *transformTargetEntry(ParseState *pstate,
+					 Node *node, Node *expr,
+					 char *colname, bool resjunk);
+extern Expr *transformAssignedExpr(ParseState *pstate, Expr *expr,
+					  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 */
--- a/pg_include/parser/parse_type.h
+++ b/pg_include/parser/parse_type.h
@@ -0,0 +1,52 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_type.h
+ *		handle type operations for parser
+ *
+ * Portions Copyright (c) 1996-2012, 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);
+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 void parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p);
+
+#define ISCOMPLEX(typeid) (typeidTypeRelid(typeid) != InvalidOid)
+
+#endif   /* PARSE_TYPE_H */
--- a/pg_include/parser/parse_utilcmd.h
+++ b/pg_include/parser/parse_utilcmd.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_utilcmd.h
+ *		parse analysis for utility commands
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parse_utilcmd.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_UTILCMD_H
+#define PARSE_UTILCMD_H
+
+#include "parser/parse_node.h"
+
+
+extern List *transformCreateStmt(CreateStmt *stmt, const char *queryString);
+extern List *transformAlterTableStmt(AlterTableStmt *stmt,
+						const char *queryString);
+extern IndexStmt *transformIndexStmt(IndexStmt *stmt, const char *queryString);
+extern void transformRuleStmt(RuleStmt *stmt, const char *queryString,
+				  List **actions, Node **whereClause);
+extern List *transformCreateSchemaStmt(CreateSchemaStmt *stmt);
+
+#endif   /* PARSE_UTILCMD_H */
--- a/pg_include/parser/parser.h
+++ b/pg_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-2012, 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 int	backslash_quote;
+extern bool escape_string_warning;
+extern PGDLLIMPORT 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 */
--- a/pg_include/parser/parsetree.h
+++ b/pg_include/parser/parsetree.h
@@ -0,0 +1,79 @@
+/*-------------------------------------------------------------------------
+ *
+ * parsetree.h
+ *	  Routines to access various components and subcomponents of
+ *	  parse trees.
+ *
+ *
+ * Portions Copyright (c) 1996-2012, 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))
+
+/*
+ *		getrelid
+ *
+ *		Given the range index of a relation, return the corresponding
+ *		relation OID.  Note that InvalidOid will be returned if the
+ *		RTE is for a non-relation-type RTE.
+ */
+#define getrelid(rangeindex,rangetable) \
+	(rt_fetch(rangeindex, rangetable)->relid)
+
+/*
+ * 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);
+
+/*
+ * Given an RTE and an attribute number, return the appropriate
+ * type and typemod info for that attribute of that RTE.
+ */
+extern void get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum,
+					   Oid *vartype, int32 *vartypmod, Oid *varcollid);
+
+/*
+ * Check whether an attribute of an RTE has been dropped (note that
+ * get_rte_attribute_type will fail on such an attr)
+ */
+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 */
--- a/pg_include/parser/scanner.h
+++ b/pg_include/parser/scanner.h
@@ -0,0 +1,119 @@
+/*-------------------------------------------------------------------------
+ *
+ * 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-2012, 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 "parser/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 FCONST SCONST BCONST XCONST Op
+ *	%token <ival>	ICONST PARAM
+ *	%token			TYPECAST DOT_DOT COLON_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.
+	 */
+	const ScanKeyword *keywords;
+	int			num_keywords;
+
+	/*
+	 * 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 */
+
+	int			xcdepth;		/* depth of nesting in slash-star comments */
+	char	   *dolqstart;		/* current $foo$ quote start string */
+
+	/* 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;
+} core_yy_extra_type;
+
+/*
+ * The type of yyscanner is opaque outside scan.l.
+ */
+typedef void *core_yyscan_t;
+
+
+/* Entry points in parser/scan.l */
+extern core_yyscan_t scanner_init(const char *str,
+			 core_yy_extra_type *yyext,
+			 const ScanKeyword *keywords,
+			 int num_keywords);
+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 scanner_yyerror(const char *message, core_yyscan_t yyscanner);
+
+#endif   /* SCANNER_H */
--- a/pg_include/parser/scansup.h
+++ b/pg_include/parser/scansup.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * scansup.h
+ *	  scanner support routines.  used by both the bootstrap lexer
+ * as well as the normal lexer
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/scansup.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef SCANSUP_H
+#define SCANSUP_H
+
+extern char *scanstr(const char *s);
+
+extern char *downcase_truncate_identifier(const char *ident, int len,
+							 bool warn);
+
+extern void truncate_identifier(char *ident, int len, bool warn);
+
+extern bool scanner_isspace(char ch);
+
+#endif   /* SCANSUP_H */