Alvaro Herrera wrote:
> Tom Lane wrote:
> > What I'd suggest is something similar to the design of the errcodes.h
> > header: create a header file containing just the list of PG_KEYWORD
> > macro calls, and have the different users #include it after defining
> > that macro appropriately. Having .c files include other .c files is
> > usually best avoided on least-surprise grounds.
>
> Seems doable.
Attached.
--
Alvaro Herrera http://www.CommandPrompt.com/
The PostgreSQL Company - Command Prompt, Inc.
Index: src/backend/parser/Makefile
===================================================================
RCS file: /home/alvherre/Code/cvs/pgsql/src/backend/parser/Makefile,v
retrieving revision 1.48
diff -c -p -r1.48 Makefile
*** src/backend/parser/Makefile 4 Oct 2008 21:56:54 -0000 1.48
--- src/backend/parser/Makefile 4 Mar 2009 15:32:52 -0000
*************** override CPPFLAGS := -I$(srcdir) $(CPPFL
*** 14,20 ****
OBJS= analyze.o gram.o keywords.o parser.o parse_agg.o parse_cte.o parse_clause.o \
parse_expr.o parse_func.o parse_node.o parse_oper.o parse_relation.o \
! parse_type.o parse_coerce.o parse_target.o parse_utilcmd.o scansup.o
FLEXFLAGS = -CF
--- 14,20 ----
OBJS= analyze.o gram.o keywords.o parser.o parse_agg.o parse_cte.o parse_clause.o \
parse_expr.o parse_func.o parse_node.o parse_oper.o parse_relation.o \
! parse_type.o parse_coerce.o parse_target.o parse_utilcmd.o scansup.o kwlookup.o
FLEXFLAGS = -CF
Index: src/backend/parser/keywords.c
===================================================================
RCS file: /home/alvherre/Code/cvs/pgsql/src/backend/parser/keywords.c,v
retrieving revision 1.210
diff -c -p -r1.210 keywords.c
*** src/backend/parser/keywords.c 24 Feb 2009 10:06:33 -0000 1.210
--- src/backend/parser/keywords.c 4 Mar 2009 15:56:35 -0000
***************
*** 3,10 ****
* keywords.c
* lexical token lookup for key words in PostgreSQL
*
- * NB: This file is also used by pg_dump.
- *
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
--- 3,8 ----
***************
*** 15,503 ****
*
*-------------------------------------------------------------------------
*/
! /* Use c.h so that this file can be built in either frontend or backend */
! #include "c.h"
!
! #include <ctype.h>
!
! /*
! * This macro definition overrides the YYSTYPE union definition in gram.h.
! * We don't need that struct in this file, and including the real definition
! * would require sucking in some backend-only include files.
! */
! #define YYSTYPE int
!
#include "parser/keywords.h"
- #ifndef ECPG_COMPILE
#include "parser/gram.h"
- #else
- #include "preproc.h"
- #endif
-
- /*
- * 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.
- */
- const ScanKeyword ScanKeywords[] = {
- /* name, value, category */
- {"abort", ABORT_P, UNRESERVED_KEYWORD},
- {"absolute", ABSOLUTE_P, UNRESERVED_KEYWORD},
- {"access", ACCESS, UNRESERVED_KEYWORD},
- {"action", ACTION, UNRESERVED_KEYWORD},
- {"add", ADD_P, UNRESERVED_KEYWORD},
- {"admin", ADMIN, UNRESERVED_KEYWORD},
- {"after", AFTER, UNRESERVED_KEYWORD},
- {"aggregate", AGGREGATE, UNRESERVED_KEYWORD},
- {"all", ALL, RESERVED_KEYWORD},
- {"also", ALSO, UNRESERVED_KEYWORD},
- {"alter", ALTER, UNRESERVED_KEYWORD},
- {"always", ALWAYS, UNRESERVED_KEYWORD},
- {"analyse", ANALYSE, RESERVED_KEYWORD}, /* British spelling */
- {"analyze", ANALYZE, RESERVED_KEYWORD},
- {"and", AND, RESERVED_KEYWORD},
- {"any", ANY, RESERVED_KEYWORD},
- {"array", ARRAY, RESERVED_KEYWORD},
- {"as", AS, RESERVED_KEYWORD},
- {"asc", ASC, RESERVED_KEYWORD},
- {"assertion", ASSERTION, UNRESERVED_KEYWORD},
- {"assignment", ASSIGNMENT, UNRESERVED_KEYWORD},
- {"asymmetric", ASYMMETRIC, RESERVED_KEYWORD},
- {"at", AT, UNRESERVED_KEYWORD},
- {"authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD},
- {"backward", BACKWARD, UNRESERVED_KEYWORD},
- {"before", BEFORE, UNRESERVED_KEYWORD},
- {"begin", BEGIN_P, UNRESERVED_KEYWORD},
- {"between", BETWEEN, TYPE_FUNC_NAME_KEYWORD},
- {"bigint", BIGINT, COL_NAME_KEYWORD},
- {"binary", BINARY, TYPE_FUNC_NAME_KEYWORD},
- {"bit", BIT, COL_NAME_KEYWORD},
- {"boolean", BOOLEAN_P, COL_NAME_KEYWORD},
- {"both", BOTH, RESERVED_KEYWORD},
- {"by", BY, UNRESERVED_KEYWORD},
- {"cache", CACHE, UNRESERVED_KEYWORD},
- {"called", CALLED, UNRESERVED_KEYWORD},
- {"cascade", CASCADE, UNRESERVED_KEYWORD},
- {"cascaded", CASCADED, UNRESERVED_KEYWORD},
- {"case", CASE, RESERVED_KEYWORD},
- {"cast", CAST, RESERVED_KEYWORD},
- {"catalog", CATALOG_P, UNRESERVED_KEYWORD},
- {"chain", CHAIN, UNRESERVED_KEYWORD},
- {"char", CHAR_P, COL_NAME_KEYWORD},
- {"character", CHARACTER, COL_NAME_KEYWORD},
- {"characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD},
- {"check", CHECK, RESERVED_KEYWORD},
- {"checkpoint", CHECKPOINT, UNRESERVED_KEYWORD},
- {"class", CLASS, UNRESERVED_KEYWORD},
- {"close", CLOSE, UNRESERVED_KEYWORD},
- {"cluster", CLUSTER, UNRESERVED_KEYWORD},
- {"coalesce", COALESCE, COL_NAME_KEYWORD},
- {"collate", COLLATE, RESERVED_KEYWORD},
- {"column", COLUMN, RESERVED_KEYWORD},
- {"comment", COMMENT, UNRESERVED_KEYWORD},
- {"commit", COMMIT, UNRESERVED_KEYWORD},
- {"committed", COMMITTED, UNRESERVED_KEYWORD},
- {"concurrently", CONCURRENTLY, UNRESERVED_KEYWORD},
- {"configuration", CONFIGURATION, UNRESERVED_KEYWORD},
- {"connection", CONNECTION, UNRESERVED_KEYWORD},
- {"constraint", CONSTRAINT, RESERVED_KEYWORD},
- {"constraints", CONSTRAINTS, UNRESERVED_KEYWORD},
- {"content", CONTENT_P, UNRESERVED_KEYWORD},
- {"continue", CONTINUE_P, UNRESERVED_KEYWORD},
- {"conversion", CONVERSION_P, UNRESERVED_KEYWORD},
- {"copy", COPY, UNRESERVED_KEYWORD},
- {"cost", COST, UNRESERVED_KEYWORD},
- {"create", CREATE, RESERVED_KEYWORD},
- {"createdb", CREATEDB, UNRESERVED_KEYWORD},
- {"createrole", CREATEROLE, UNRESERVED_KEYWORD},
- {"createuser", CREATEUSER, UNRESERVED_KEYWORD},
- {"cross", CROSS, TYPE_FUNC_NAME_KEYWORD},
- {"csv", CSV, UNRESERVED_KEYWORD},
- {"ctype", CTYPE, UNRESERVED_KEYWORD},
- {"current", CURRENT_P, UNRESERVED_KEYWORD},
- {"current_catalog", CURRENT_CATALOG, RESERVED_KEYWORD},
- {"current_date", CURRENT_DATE, RESERVED_KEYWORD},
- {"current_role", CURRENT_ROLE, RESERVED_KEYWORD},
- {"current_schema", CURRENT_SCHEMA, TYPE_FUNC_NAME_KEYWORD},
- {"current_time", CURRENT_TIME, RESERVED_KEYWORD},
- {"current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD},
- {"current_user", CURRENT_USER, RESERVED_KEYWORD},
- {"cursor", CURSOR, UNRESERVED_KEYWORD},
- {"cycle", CYCLE, UNRESERVED_KEYWORD},
- {"data", DATA_P, UNRESERVED_KEYWORD},
- {"database", DATABASE, UNRESERVED_KEYWORD},
- {"day", DAY_P, UNRESERVED_KEYWORD},
- {"deallocate", DEALLOCATE, UNRESERVED_KEYWORD},
- {"dec", DEC, COL_NAME_KEYWORD},
- {"decimal", DECIMAL_P, COL_NAME_KEYWORD},
- {"declare", DECLARE, UNRESERVED_KEYWORD},
- {"default", DEFAULT, RESERVED_KEYWORD},
- {"defaults", DEFAULTS, UNRESERVED_KEYWORD},
- {"deferrable", DEFERRABLE, RESERVED_KEYWORD},
- {"deferred", DEFERRED, UNRESERVED_KEYWORD},
- {"definer", DEFINER, UNRESERVED_KEYWORD},
- {"delete", DELETE_P, UNRESERVED_KEYWORD},
- {"delimiter", DELIMITER, UNRESERVED_KEYWORD},
- {"delimiters", DELIMITERS, UNRESERVED_KEYWORD},
- {"desc", DESC, RESERVED_KEYWORD},
- {"dictionary", DICTIONARY, UNRESERVED_KEYWORD},
- {"disable", DISABLE_P, UNRESERVED_KEYWORD},
- {"discard", DISCARD, UNRESERVED_KEYWORD},
- {"distinct", DISTINCT, RESERVED_KEYWORD},
- {"do", DO, RESERVED_KEYWORD},
- {"document", DOCUMENT_P, UNRESERVED_KEYWORD},
- {"domain", DOMAIN_P, UNRESERVED_KEYWORD},
- {"double", DOUBLE_P, UNRESERVED_KEYWORD},
- {"drop", DROP, UNRESERVED_KEYWORD},
- {"each", EACH, UNRESERVED_KEYWORD},
- {"else", ELSE, RESERVED_KEYWORD},
- {"enable", ENABLE_P, UNRESERVED_KEYWORD},
- {"encoding", ENCODING, UNRESERVED_KEYWORD},
- {"encrypted", ENCRYPTED, UNRESERVED_KEYWORD},
- {"end", END_P, RESERVED_KEYWORD},
- {"enum", ENUM_P, UNRESERVED_KEYWORD},
- {"escape", ESCAPE, UNRESERVED_KEYWORD},
- {"except", EXCEPT, RESERVED_KEYWORD},
- {"excluding", EXCLUDING, UNRESERVED_KEYWORD},
- {"exclusive", EXCLUSIVE, UNRESERVED_KEYWORD},
- {"execute", EXECUTE, UNRESERVED_KEYWORD},
- {"exists", EXISTS, COL_NAME_KEYWORD},
- {"explain", EXPLAIN, UNRESERVED_KEYWORD},
- {"external", EXTERNAL, UNRESERVED_KEYWORD},
- {"extract", EXTRACT, COL_NAME_KEYWORD},
- {"false", FALSE_P, RESERVED_KEYWORD},
- {"family", FAMILY, UNRESERVED_KEYWORD},
- {"fetch", FETCH, RESERVED_KEYWORD},
- {"first", FIRST_P, UNRESERVED_KEYWORD},
- {"float", FLOAT_P, COL_NAME_KEYWORD},
- {"following", FOLLOWING, UNRESERVED_KEYWORD},
- {"for", FOR, RESERVED_KEYWORD},
- {"force", FORCE, UNRESERVED_KEYWORD},
- {"foreign", FOREIGN, RESERVED_KEYWORD},
- {"forward", FORWARD, UNRESERVED_KEYWORD},
- {"freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD},
- {"from", FROM, RESERVED_KEYWORD},
- {"full", FULL, TYPE_FUNC_NAME_KEYWORD},
- {"function", FUNCTION, UNRESERVED_KEYWORD},
- {"global", GLOBAL, UNRESERVED_KEYWORD},
- {"grant", GRANT, RESERVED_KEYWORD},
- {"granted", GRANTED, UNRESERVED_KEYWORD},
- {"greatest", GREATEST, COL_NAME_KEYWORD},
- {"group", GROUP_P, RESERVED_KEYWORD},
- {"handler", HANDLER, UNRESERVED_KEYWORD},
- {"having", HAVING, RESERVED_KEYWORD},
- {"header", HEADER_P, UNRESERVED_KEYWORD},
- {"hold", HOLD, UNRESERVED_KEYWORD},
- {"hour", HOUR_P, UNRESERVED_KEYWORD},
- {"identity", IDENTITY_P, UNRESERVED_KEYWORD},
- {"if", IF_P, UNRESERVED_KEYWORD},
- {"ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD},
- {"immediate", IMMEDIATE, UNRESERVED_KEYWORD},
- {"immutable", IMMUTABLE, UNRESERVED_KEYWORD},
- {"implicit", IMPLICIT_P, UNRESERVED_KEYWORD},
- {"in", IN_P, RESERVED_KEYWORD},
- {"including", INCLUDING, UNRESERVED_KEYWORD},
- {"increment", INCREMENT, UNRESERVED_KEYWORD},
- {"index", INDEX, UNRESERVED_KEYWORD},
- {"indexes", INDEXES, UNRESERVED_KEYWORD},
- {"inherit", INHERIT, UNRESERVED_KEYWORD},
- {"inherits", INHERITS, UNRESERVED_KEYWORD},
- {"initially", INITIALLY, RESERVED_KEYWORD},
- {"inner", INNER_P, TYPE_FUNC_NAME_KEYWORD},
- {"inout", INOUT, COL_NAME_KEYWORD},
- {"input", INPUT_P, UNRESERVED_KEYWORD},
- {"insensitive", INSENSITIVE, UNRESERVED_KEYWORD},
- {"insert", INSERT, UNRESERVED_KEYWORD},
- {"instead", INSTEAD, UNRESERVED_KEYWORD},
- {"int", INT_P, COL_NAME_KEYWORD},
- {"integer", INTEGER, COL_NAME_KEYWORD},
- {"intersect", INTERSECT, RESERVED_KEYWORD},
- {"interval", INTERVAL, COL_NAME_KEYWORD},
- {"into", INTO, RESERVED_KEYWORD},
- {"invoker", INVOKER, UNRESERVED_KEYWORD},
- {"is", IS, TYPE_FUNC_NAME_KEYWORD},
- {"isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD},
- {"isolation", ISOLATION, UNRESERVED_KEYWORD},
- {"join", JOIN, TYPE_FUNC_NAME_KEYWORD},
- {"key", KEY, UNRESERVED_KEYWORD},
- {"lancompiler", LANCOMPILER, UNRESERVED_KEYWORD},
- {"language", LANGUAGE, UNRESERVED_KEYWORD},
- {"large", LARGE_P, UNRESERVED_KEYWORD},
- {"last", LAST_P, UNRESERVED_KEYWORD},
- {"leading", LEADING, RESERVED_KEYWORD},
- {"least", LEAST, COL_NAME_KEYWORD},
- {"left", LEFT, TYPE_FUNC_NAME_KEYWORD},
- {"level", LEVEL, UNRESERVED_KEYWORD},
- {"like", LIKE, TYPE_FUNC_NAME_KEYWORD},
- {"limit", LIMIT, RESERVED_KEYWORD},
- {"listen", LISTEN, UNRESERVED_KEYWORD},
- {"load", LOAD, UNRESERVED_KEYWORD},
- {"local", LOCAL, UNRESERVED_KEYWORD},
- {"localtime", LOCALTIME, RESERVED_KEYWORD},
- {"localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD},
- {"location", LOCATION, UNRESERVED_KEYWORD},
- {"lock", LOCK_P, UNRESERVED_KEYWORD},
- {"login", LOGIN_P, UNRESERVED_KEYWORD},
- {"mapping", MAPPING, UNRESERVED_KEYWORD},
- {"match", MATCH, UNRESERVED_KEYWORD},
- {"maxvalue", MAXVALUE, UNRESERVED_KEYWORD},
- {"minute", MINUTE_P, UNRESERVED_KEYWORD},
- {"minvalue", MINVALUE, UNRESERVED_KEYWORD},
- {"mode", MODE, UNRESERVED_KEYWORD},
- {"month", MONTH_P, UNRESERVED_KEYWORD},
- {"move", MOVE, UNRESERVED_KEYWORD},
- {"name", NAME_P, UNRESERVED_KEYWORD},
- {"names", NAMES, UNRESERVED_KEYWORD},
- {"national", NATIONAL, COL_NAME_KEYWORD},
- {"natural", NATURAL, TYPE_FUNC_NAME_KEYWORD},
- {"nchar", NCHAR, COL_NAME_KEYWORD},
- {"new", NEW, RESERVED_KEYWORD},
- {"next", NEXT, UNRESERVED_KEYWORD},
- {"no", NO, UNRESERVED_KEYWORD},
- {"nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD},
- {"nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD},
- {"nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD},
- {"noinherit", NOINHERIT, UNRESERVED_KEYWORD},
- {"nologin", NOLOGIN_P, UNRESERVED_KEYWORD},
- {"none", NONE, COL_NAME_KEYWORD},
- {"nosuperuser", NOSUPERUSER, UNRESERVED_KEYWORD},
- {"not", NOT, RESERVED_KEYWORD},
- {"nothing", NOTHING, UNRESERVED_KEYWORD},
- {"notify", NOTIFY, UNRESERVED_KEYWORD},
- {"notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD},
- {"nowait", NOWAIT, UNRESERVED_KEYWORD},
- {"null", NULL_P, RESERVED_KEYWORD},
- {"nullif", NULLIF, COL_NAME_KEYWORD},
- {"nulls", NULLS_P, UNRESERVED_KEYWORD},
- {"numeric", NUMERIC, COL_NAME_KEYWORD},
- {"object", OBJECT_P, UNRESERVED_KEYWORD},
- {"of", OF, UNRESERVED_KEYWORD},
- {"off", OFF, RESERVED_KEYWORD},
- {"offset", OFFSET, RESERVED_KEYWORD},
- {"oids", OIDS, UNRESERVED_KEYWORD},
- {"old", OLD, RESERVED_KEYWORD},
- {"on", ON, RESERVED_KEYWORD},
- {"only", ONLY, RESERVED_KEYWORD},
- {"operator", OPERATOR, UNRESERVED_KEYWORD},
- {"option", OPTION, UNRESERVED_KEYWORD},
- {"options", OPTIONS, UNRESERVED_KEYWORD},
- {"or", OR, RESERVED_KEYWORD},
- {"order", ORDER, RESERVED_KEYWORD},
- {"out", OUT_P, COL_NAME_KEYWORD},
- {"outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD},
- {"over", OVER, TYPE_FUNC_NAME_KEYWORD},
- {"overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD},
- {"overlay", OVERLAY, COL_NAME_KEYWORD},
- {"owned", OWNED, UNRESERVED_KEYWORD},
- {"owner", OWNER, UNRESERVED_KEYWORD},
- {"parser", PARSER, UNRESERVED_KEYWORD},
- {"partial", PARTIAL, UNRESERVED_KEYWORD},
- {"partition", PARTITION, UNRESERVED_KEYWORD},
- {"password", PASSWORD, UNRESERVED_KEYWORD},
- {"placing", PLACING, RESERVED_KEYWORD},
- {"plans", PLANS, UNRESERVED_KEYWORD},
- {"position", POSITION, COL_NAME_KEYWORD},
- {"preceding", PRECEDING, UNRESERVED_KEYWORD},
- {"precision", PRECISION, COL_NAME_KEYWORD},
- {"prepare", PREPARE, UNRESERVED_KEYWORD},
- {"prepared", PREPARED, UNRESERVED_KEYWORD},
- {"preserve", PRESERVE, UNRESERVED_KEYWORD},
- {"primary", PRIMARY, RESERVED_KEYWORD},
- {"prior", PRIOR, UNRESERVED_KEYWORD},
- {"privileges", PRIVILEGES, UNRESERVED_KEYWORD},
- {"procedural", PROCEDURAL, UNRESERVED_KEYWORD},
- {"procedure", PROCEDURE, UNRESERVED_KEYWORD},
- {"quote", QUOTE, UNRESERVED_KEYWORD},
- {"range", RANGE, UNRESERVED_KEYWORD},
- {"read", READ, UNRESERVED_KEYWORD},
- {"real", REAL, COL_NAME_KEYWORD},
- {"reassign", REASSIGN, UNRESERVED_KEYWORD},
- {"recheck", RECHECK, UNRESERVED_KEYWORD},
- {"recursive", RECURSIVE, UNRESERVED_KEYWORD},
- {"references", REFERENCES, RESERVED_KEYWORD},
- {"reindex", REINDEX, UNRESERVED_KEYWORD},
- {"relative", RELATIVE_P, UNRESERVED_KEYWORD},
- {"release", RELEASE, UNRESERVED_KEYWORD},
- {"rename", RENAME, UNRESERVED_KEYWORD},
- {"repeatable", REPEATABLE, UNRESERVED_KEYWORD},
- {"replace", REPLACE, UNRESERVED_KEYWORD},
- {"replica", REPLICA, UNRESERVED_KEYWORD},
- {"reset", RESET, UNRESERVED_KEYWORD},
- {"restart", RESTART, UNRESERVED_KEYWORD},
- {"restrict", RESTRICT, UNRESERVED_KEYWORD},
- {"returning", RETURNING, RESERVED_KEYWORD},
- {"returns", RETURNS, UNRESERVED_KEYWORD},
- {"revoke", REVOKE, UNRESERVED_KEYWORD},
- {"right", RIGHT, TYPE_FUNC_NAME_KEYWORD},
- {"role", ROLE, UNRESERVED_KEYWORD},
- {"rollback", ROLLBACK, UNRESERVED_KEYWORD},
- {"row", ROW, COL_NAME_KEYWORD},
- {"rows", ROWS, UNRESERVED_KEYWORD},
- {"rule", RULE, UNRESERVED_KEYWORD},
- {"savepoint", SAVEPOINT, UNRESERVED_KEYWORD},
- {"schema", SCHEMA, UNRESERVED_KEYWORD},
- {"scroll", SCROLL, UNRESERVED_KEYWORD},
- {"search", SEARCH, UNRESERVED_KEYWORD},
- {"second", SECOND_P, UNRESERVED_KEYWORD},
- {"security", SECURITY, UNRESERVED_KEYWORD},
- {"select", SELECT, RESERVED_KEYWORD},
- {"sequence", SEQUENCE, UNRESERVED_KEYWORD},
- {"serializable", SERIALIZABLE, UNRESERVED_KEYWORD},
- {"server", SERVER, UNRESERVED_KEYWORD},
- {"session", SESSION, UNRESERVED_KEYWORD},
- {"session_user", SESSION_USER, RESERVED_KEYWORD},
- {"set", SET, UNRESERVED_KEYWORD},
- {"setof", SETOF, COL_NAME_KEYWORD},
- {"share", SHARE, UNRESERVED_KEYWORD},
- {"show", SHOW, UNRESERVED_KEYWORD},
- {"similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD},
- {"simple", SIMPLE, UNRESERVED_KEYWORD},
- {"smallint", SMALLINT, COL_NAME_KEYWORD},
- {"some", SOME, RESERVED_KEYWORD},
- {"stable", STABLE, UNRESERVED_KEYWORD},
- {"standalone", STANDALONE_P, UNRESERVED_KEYWORD},
- {"start", START, UNRESERVED_KEYWORD},
- {"statement", STATEMENT, UNRESERVED_KEYWORD},
- {"statistics", STATISTICS, UNRESERVED_KEYWORD},
- {"stdin", STDIN, UNRESERVED_KEYWORD},
- {"stdout", STDOUT, UNRESERVED_KEYWORD},
- {"storage", STORAGE, UNRESERVED_KEYWORD},
- {"strict", STRICT_P, UNRESERVED_KEYWORD},
- {"strip", STRIP_P, UNRESERVED_KEYWORD},
- {"substring", SUBSTRING, COL_NAME_KEYWORD},
- {"superuser", SUPERUSER_P, UNRESERVED_KEYWORD},
- {"symmetric", SYMMETRIC, RESERVED_KEYWORD},
- {"sysid", SYSID, UNRESERVED_KEYWORD},
- {"system", SYSTEM_P, UNRESERVED_KEYWORD},
- {"table", TABLE, RESERVED_KEYWORD},
- {"tablespace", TABLESPACE, UNRESERVED_KEYWORD},
- {"temp", TEMP, UNRESERVED_KEYWORD},
- {"template", TEMPLATE, UNRESERVED_KEYWORD},
- {"temporary", TEMPORARY, UNRESERVED_KEYWORD},
- {"text", TEXT_P, UNRESERVED_KEYWORD},
- {"then", THEN, RESERVED_KEYWORD},
- {"time", TIME, COL_NAME_KEYWORD},
- {"timestamp", TIMESTAMP, COL_NAME_KEYWORD},
- {"to", TO, RESERVED_KEYWORD},
- {"trailing", TRAILING, RESERVED_KEYWORD},
- {"transaction", TRANSACTION, UNRESERVED_KEYWORD},
- {"treat", TREAT, COL_NAME_KEYWORD},
- {"trigger", TRIGGER, UNRESERVED_KEYWORD},
- {"trim", TRIM, COL_NAME_KEYWORD},
- {"true", TRUE_P, RESERVED_KEYWORD},
- {"truncate", TRUNCATE, UNRESERVED_KEYWORD},
- {"trusted", TRUSTED, UNRESERVED_KEYWORD},
- {"type", TYPE_P, UNRESERVED_KEYWORD},
- {"unbounded", UNBOUNDED, UNRESERVED_KEYWORD},
- {"uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD},
- {"unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD},
- {"union", UNION, RESERVED_KEYWORD},
- {"unique", UNIQUE, RESERVED_KEYWORD},
- {"unknown", UNKNOWN, UNRESERVED_KEYWORD},
- {"unlisten", UNLISTEN, UNRESERVED_KEYWORD},
- {"until", UNTIL, UNRESERVED_KEYWORD},
- {"update", UPDATE, UNRESERVED_KEYWORD},
- {"user", USER, RESERVED_KEYWORD},
- {"using", USING, RESERVED_KEYWORD},
- {"vacuum", VACUUM, UNRESERVED_KEYWORD},
- {"valid", VALID, UNRESERVED_KEYWORD},
- {"validator", VALIDATOR, UNRESERVED_KEYWORD},
- {"value", VALUE_P, UNRESERVED_KEYWORD},
- {"values", VALUES, COL_NAME_KEYWORD},
- {"varchar", VARCHAR, COL_NAME_KEYWORD},
- {"variadic", VARIADIC, RESERVED_KEYWORD},
- {"varying", VARYING, UNRESERVED_KEYWORD},
- {"verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD},
- {"version", VERSION_P, UNRESERVED_KEYWORD},
- {"view", VIEW, UNRESERVED_KEYWORD},
- {"volatile", VOLATILE, UNRESERVED_KEYWORD},
- {"when", WHEN, RESERVED_KEYWORD},
- {"where", WHERE, RESERVED_KEYWORD},
- {"whitespace", WHITESPACE_P, UNRESERVED_KEYWORD},
- {"window", WINDOW, RESERVED_KEYWORD},
- {"with", WITH, RESERVED_KEYWORD},
- {"without", WITHOUT, UNRESERVED_KEYWORD},
- {"work", WORK, UNRESERVED_KEYWORD},
- {"wrapper", WRAPPER, UNRESERVED_KEYWORD},
- {"write", WRITE, UNRESERVED_KEYWORD},
- {"xml", XML_P, UNRESERVED_KEYWORD},
- {"xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD},
- {"xmlconcat", XMLCONCAT, COL_NAME_KEYWORD},
- {"xmlelement", XMLELEMENT, COL_NAME_KEYWORD},
- {"xmlforest", XMLFOREST, COL_NAME_KEYWORD},
- {"xmlparse", XMLPARSE, COL_NAME_KEYWORD},
- {"xmlpi", XMLPI, COL_NAME_KEYWORD},
- {"xmlroot", XMLROOT, COL_NAME_KEYWORD},
- {"xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD},
- {"year", YEAR_P, UNRESERVED_KEYWORD},
- {"yes", YES_P, UNRESERVED_KEYWORD},
- {"zone", ZONE, UNRESERVED_KEYWORD},
- };
-
- /* End of ScanKeywords, for use elsewhere */
- const ScanKeyword *LastScanKeyword = endof(ScanKeywords);
-
- /*
- * ScanKeywordLookup - see if a given word is a keyword
- *
- * Returns a pointer to the ScanKeyword table entry, or NULL if no match.
- *
- * The match is done case-insensitively. Note that we deliberately use a
- * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z',
- * even if we are in a locale where tolower() would produce more or different
- * translations. This is to conform to the SQL99 spec, which says that
- * keywords are to be matched in this way even though non-keyword identifiers
- * receive a different case-normalization mapping.
- */
- const ScanKeyword *
- ScanKeywordLookup(const char *text)
- {
- int len,
- i;
- char word[NAMEDATALEN];
- const ScanKeyword *low;
- const ScanKeyword *high;
-
- len = strlen(text);
- /* We assume all keywords are shorter than NAMEDATALEN. */
- if (len >= NAMEDATALEN)
- return NULL;
-
- /*
- * Apply an ASCII-only downcasing. We must not use tolower() since it may
- * produce the wrong translation in some locales (eg, Turkish).
- */
- for (i = 0; i < len; i++)
- {
- char ch = text[i];
-
- if (ch >= 'A' && ch <= 'Z')
- ch += 'a' - 'A';
- word[i] = ch;
- }
- word[len] = '\0';
-
- /*
- * Now do a binary search using plain strcmp() comparison.
- */
- low = &ScanKeywords[0];
- high = endof(ScanKeywords) - 1;
- while (low <= high)
- {
- const ScanKeyword *middle;
- int difference;
! middle = low + (high - low) / 2;
! difference = strcmp(middle->name, word);
! if (difference == 0)
! return middle;
! else if (difference < 0)
! low = middle + 1;
! else
! high = middle - 1;
! }
! return NULL;
! }
--- 13,25 ----
*
*-------------------------------------------------------------------------
*/
+ #include "postgres.h"
! #include "nodes/nodes.h"
! #include "nodes/parsenodes.h"
#include "parser/keywords.h"
#include "parser/gram.h"
! #define PG_KEYWORD(a,b,c) {a,b,c}
! #include "parser/kwlist.h"
Index: src/backend/parser/kwlookup.c
===================================================================
RCS file: src/backend/parser/kwlookup.c
diff -N src/backend/parser/kwlookup.c
*** /dev/null 1 Jan 1970 00:00:00 -0000
--- src/backend/parser/kwlookup.c 4 Mar 2009 15:42:33 -0000
***************
*** 0 ****
--- 1,86 ----
+ /*-------------------------------------------------------------------------
+ *
+ * kwlookup.c
+ * lexical token lookup for key words in PostgreSQL
+ *
+ * NB - this file is used by pg_dump and ECPG
+ *
+ * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+
+ /* use c.h so this can be built as either frontend or backend */
+ #include "c.h"
+
+ #include <ctype.h>
+
+ #include "parser/keywords.h"
+
+ /*
+ * ScanKeywordLookup - see if a given word is a keyword
+ *
+ * Returns a pointer to the ScanKeyword table entry, or NULL if no match.
+ *
+ * The match is done case-insensitively. Note that we deliberately use a
+ * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z',
+ * even if we are in a locale where tolower() would produce more or different
+ * translations. This is to conform to the SQL99 spec, which says that
+ * keywords are to be matched in this way even though non-keyword identifiers
+ * receive a different case-normalization mapping.
+ */
+ const ScanKeyword *
+ ScanKeywordLookup(const char *text)
+ {
+ int len,
+ i;
+ char word[NAMEDATALEN];
+ const ScanKeyword *low;
+ const ScanKeyword *high;
+
+ len = strlen(text);
+ /* We assume all keywords are shorter than NAMEDATALEN. */
+ if (len >= NAMEDATALEN)
+ return NULL;
+
+ /*
+ * Apply an ASCII-only downcasing. We must not use tolower() since it may
+ * produce the wrong translation in some locales (eg, Turkish).
+ */
+ for (i = 0; i < len; i++)
+ {
+ char ch = text[i];
+
+ if (ch >= 'A' && ch <= 'Z')
+ ch += 'a' - 'A';
+ word[i] = ch;
+ }
+ word[len] = '\0';
+
+ /*
+ * Now do a binary search using plain strcmp() comparison.
+ */
+ low = &ScanKeywords[0];
+ high = LastScanKeyword - 1;
+ while (low <= high)
+ {
+ const ScanKeyword *middle;
+ int difference;
+
+ middle = low + (high - low) / 2;
+ difference = strcmp(middle->name, word);
+ if (difference == 0)
+ return middle;
+ else if (difference < 0)
+ low = middle + 1;
+ else
+ high = middle - 1;
+ }
+
+ return NULL;
+ }
Index: src/bin/pg_dump/Makefile
===================================================================
RCS file: /home/alvherre/Code/cvs/pgsql/src/bin/pg_dump/Makefile,v
retrieving revision 1.66
diff -c -p -r1.66 Makefile
*** src/bin/pg_dump/Makefile 1 Jan 2009 17:23:54 -0000 1.66
--- src/bin/pg_dump/Makefile 4 Mar 2009 15:25:11 -0000
*************** OBJS= pg_backup_archiver.o pg_backup_db.
*** 20,42 ****
pg_backup_files.o pg_backup_null.o pg_backup_tar.o \
dumputils.o $(WIN32RES)
! EXTRA_OBJS = $(top_builddir)/src/backend/parser/keywords.o
! all: submake-libpq submake-libpgport submake-backend pg_dump pg_restore pg_dumpall
pg_dump: pg_dump.o common.o pg_dump_sort.o $(OBJS) $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(OBJS) $(EXTRA_OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
pg_restore: pg_restore.o $(OBJS) $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_restore.o $(OBJS) $(EXTRA_OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
pg_dumpall: pg_dumpall.o dumputils.o $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(EXTRA_OBJS) $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
!
! .PHONY: submake-backend
! submake-backend:
! $(MAKE) -C $(top_builddir)/src/backend/parser keywords.o
!
install: all installdirs
$(INSTALL_PROGRAM) pg_dump$(X) '$(DESTDIR)$(bindir)'/pg_dump$(X)
--- 20,40 ----
pg_backup_files.o pg_backup_null.o pg_backup_tar.o \
dumputils.o $(WIN32RES)
! KEYWRDOBJS = keywords.o kwlookup.o
! kwlookup.c: % : $(top_srcdir)/src/backend/parser/%
! rm -f $@ && $(LN_S) $< .
!
! all: submake-libpq submake-libpgport pg_dump pg_restore pg_dumpall
pg_dump: pg_dump.o common.o pg_dump_sort.o $(OBJS) $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
pg_restore: pg_restore.o $(OBJS) $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_restore.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
pg_dumpall: pg_dumpall.o dumputils.o $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(KEYWRDOBJS) $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
install: all installdirs
$(INSTALL_PROGRAM) pg_dump$(X) '$(DESTDIR)$(bindir)'/pg_dump$(X)
*************** uninstall:
*** 50,53 ****
rm -f $(addprefix '$(DESTDIR)$(bindir)'/, pg_dump$(X) pg_restore$(X) pg_dumpall$(X))
clean distclean maintainer-clean:
! rm -f pg_dump$(X) pg_restore$(X) pg_dumpall$(X) $(OBJS) pg_dump.o common.o pg_dump_sort.o pg_restore.o pg_dumpall.o
--- 48,51 ----
rm -f $(addprefix '$(DESTDIR)$(bindir)'/, pg_dump$(X) pg_restore$(X) pg_dumpall$(X))
clean distclean maintainer-clean:
! rm -f pg_dump$(X) pg_restore$(X) pg_dumpall$(X) $(OBJS) pg_dump.o common.o pg_dump_sort.o pg_restore.o pg_dumpall.o kwlookup.c $(KEYWRDOBJS)
Index: src/bin/pg_dump/keywords.c
===================================================================
RCS file: src/bin/pg_dump/keywords.c
diff -N src/bin/pg_dump/keywords.c
*** /dev/null 1 Jan 1970 00:00:00 -0000
--- src/bin/pg_dump/keywords.c 4 Mar 2009 16:08:22 -0000
***************
*** 0 ****
--- 1,34 ----
+ /*-------------------------------------------------------------------------
+ *
+ * keywords.c
+ * lexical token lookup for key words in PostgreSQL
+ *
+ *
+ * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #include "postgres_fe.h"
+
+ /*
+ * This macro definition overrides the YYSTYPE union definition in gram.h.
+ * We don't need that struct in this file, and including the real definition
+ * would require sucking in some backend-only include files.
+ */
+ #define YYSTYPE int
+
+ #include "parser/keywords.h"
+
+ /*
+ * We don't need the token number, so leave it out to avoid requiring extra
+ * object files from the backend.
+ */
+ #define PG_KEYWORD(a,b,c) {a,c}
+ #define TWO_MEMBER_SCANKEYWORD
+
+ #include "parser/kwlist.h"
Index: src/include/parser/keywords.h
===================================================================
RCS file: /home/alvherre/Code/cvs/pgsql/src/include/parser/keywords.h,v
retrieving revision 1.26
diff -c -p -r1.26 keywords.h
*** src/include/parser/keywords.h 1 Jan 2009 17:24:00 -0000 1.26
--- src/include/parser/keywords.h 4 Mar 2009 15:58:10 -0000
***************
*** 24,30 ****
--- 24,32 ----
typedef struct ScanKeyword
{
const char *name; /* in lower case */
+ #ifndef TWO_MEMBER_SCANKEYWORD
int16 value; /* grammar's token code */
+ #endif
int16 category; /* see codes above */
} ScanKeyword;
Index: src/include/parser/kwlist.h
===================================================================
RCS file: src/include/parser/kwlist.h
diff -N src/include/parser/kwlist.h
*** /dev/null 1 Jan 1970 00:00:00 -0000
--- src/include/parser/kwlist.h 4 Mar 2009 15:55:55 -0000
***************
*** 0 ****
--- 1,426 ----
+ /*-------------------------------------------------------------------------
+ *
+ * kwlist.h
+ * keyword list definitions for PostgreSQL
+ *
+ *
+ * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #ifndef KWLIST_H
+ #define KWLIST_H
+
+ #include "parser/keywords.h"
+
+
+ /*
+ * 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.
+ */
+ const ScanKeyword ScanKeywords[] = {
+ /* 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("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, TYPE_FUNC_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("column", COLUMN, RESERVED_KEYWORD),
+ PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD),
+ PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD),
+ PG_KEYWORD("committed", COMMITTED, UNRESERVED_KEYWORD),
+ PG_KEYWORD("concurrently", CONCURRENTLY, UNRESERVED_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("createdb", CREATEDB, UNRESERVED_KEYWORD),
+ PG_KEYWORD("createrole", CREATEROLE, UNRESERVED_KEYWORD),
+ PG_KEYWORD("createuser", CREATEUSER, UNRESERVED_KEYWORD),
+ PG_KEYWORD("cross", CROSS, TYPE_FUNC_NAME_KEYWORD),
+ PG_KEYWORD("csv", CSV, UNRESERVED_KEYWORD),
+ PG_KEYWORD("ctype", CTYPE, 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("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("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("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("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("lancompiler", LANCOMPILER, UNRESERVED_KEYWORD),
+ PG_KEYWORD("language", LANGUAGE, UNRESERVED_KEYWORD),
+ PG_KEYWORD("large", LARGE_P, UNRESERVED_KEYWORD),
+ PG_KEYWORD("last", LAST_P, UNRESERVED_KEYWORD),
+ PG_KEYWORD("leading", LEADING, RESERVED_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("login", LOGIN_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("new", NEW, RESERVED_KEYWORD),
+ PG_KEYWORD("next", NEXT, UNRESERVED_KEYWORD),
+ PG_KEYWORD("no", NO, UNRESERVED_KEYWORD),
+ PG_KEYWORD("nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD),
+ PG_KEYWORD("nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD),
+ PG_KEYWORD("nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD),
+ PG_KEYWORD("noinherit", NOINHERIT, UNRESERVED_KEYWORD),
+ PG_KEYWORD("nologin", NOLOGIN_P, UNRESERVED_KEYWORD),
+ PG_KEYWORD("none", NONE, COL_NAME_KEYWORD),
+ PG_KEYWORD("nosuperuser", NOSUPERUSER, UNRESERVED_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, RESERVED_KEYWORD),
+ PG_KEYWORD("offset", OFFSET, RESERVED_KEYWORD),
+ PG_KEYWORD("oids", OIDS, UNRESERVED_KEYWORD),
+ PG_KEYWORD("old", OLD, RESERVED_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("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("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("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("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("superuser", SUPERUSER_P, UNRESERVED_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("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("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("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("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("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),
+ };
+
+ /* End of ScanKeywords, for use elsewhere */
+ const ScanKeyword *LastScanKeyword = endof(ScanKeywords);
+
+ #endif /* KWLIST_H */
Index: src/interfaces/ecpg/preproc/Makefile
===================================================================
RCS file: /home/alvherre/Code/cvs/pgsql/src/interfaces/ecpg/preproc/Makefile,v
retrieving revision 1.141
diff -c -p -r1.141 Makefile
*** src/interfaces/ecpg/preproc/Makefile 1 Jan 2009 17:24:02 -0000 1.141
--- src/interfaces/ecpg/preproc/Makefile 4 Mar 2009 15:46:40 -0000
*************** override CPPFLAGS := -I../include -I$(to
*** 25,31 ****
override CFLAGS += $(PTHREAD_CFLAGS) -DECPG_COMPILE
OBJS= preproc.o type.o ecpg.o output.o parser.o \
! keywords.o c_keywords.o ecpg_keywords.o ../ecpglib/typename.o descriptor.o variable.o \
$(WIN32RES)
all: submake-libpgport ecpg
--- 25,31 ----
override CFLAGS += $(PTHREAD_CFLAGS) -DECPG_COMPILE
OBJS= preproc.o type.o ecpg.o output.o parser.o \
! keywords.o c_keywords.o ecpg_keywords.o kwlookup.o ../ecpglib/typename.o descriptor.o variable.o \
$(WIN32RES)
all: submake-libpgport ecpg
*************** $(srcdir)/preproc.y: $(top_srcdir)/src/b
*** 57,64 ****
ecpg_keywords.o c_keywords.o keywords.o preproc.o parser.o: preproc.h
! # instead of maintaining our own list, take the one from the backend
! keywords.c: % : $(top_srcdir)/src/backend/parser/%
rm -f $@ && $(LN_S) $< .
distprep: $(srcdir)/preproc.y $(srcdir)/preproc.c $(srcdir)/preproc.h $(srcdir)/pgc.c
--- 57,63 ----
ecpg_keywords.o c_keywords.o keywords.o preproc.o parser.o: preproc.h
! kwlookup.c: % : $(top_srcdir)/src/backend/parser/%
rm -f $@ && $(LN_S) $< .
distprep: $(srcdir)/preproc.y $(srcdir)/preproc.c $(srcdir)/preproc.h $(srcdir)/pgc.c
*************** uninstall:
*** 73,79 ****
rm -f '$(DESTDIR)$(bindir)/ecpg$(X)'
clean distclean:
! rm -f keywords.c *.o ecpg$(X)
# garbage from development
@rm -f core a.out
--- 72,78 ----
rm -f '$(DESTDIR)$(bindir)/ecpg$(X)'
clean distclean:
! rm -f kwlookup.c *.o ecpg$(X)
# garbage from development
@rm -f core a.out
Index: src/interfaces/ecpg/preproc/keywords.c
===================================================================
RCS file: src/interfaces/ecpg/preproc/keywords.c
diff -N src/interfaces/ecpg/preproc/keywords.c
*** /dev/null 1 Jan 1970 00:00:00 -0000
--- src/interfaces/ecpg/preproc/keywords.c 4 Mar 2009 16:01:36 -0000
***************
*** 0 ****
--- 1,30 ----
+ /*-------------------------------------------------------------------------
+ *
+ * keywords.c
+ * lexical token lookup for key words in PostgreSQL
+ *
+ *
+ * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.210 2009-02-24 10:06:33 petere Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+ #include "postgres_fe.h"
+
+ /*
+ * This macro definition overrides the YYSTYPE union definition in gram.h.
+ * We don't need that struct in this file, and including the real definition
+ * would require sucking in some backend-only include files.
+ */
+ #define YYSTYPE int
+
+ #include "parser/keywords.h"
+ #include "preproc.h"
+
+ #define PG_KEYWORD(a,b,c) {a,b,c}
+
+ #include "parser/kwlist.h"
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
