Tom Lane wrote:
> Alvaro Herrera <alvhe...@commandprompt.com> writes:
> >> Seems doable.
>
> > Attached.
>
> The TWO_MEMBER_SCANKEYWORD business seems a bit dangerous --- if the
> header file is read without having #defined that correctly, bad things
> will happen. It might be better to leave that out, always define the
> struct the same, and just have pg_dump define PG_KEYWORD to fill the
> value field with zero. Given alignment considerations, you're not
> saving any space by omitting the field anyhow.
Fixed.
I also added #include type.h to the ecpg keywords.c file, which means we
don't need to redefine YYSTYPE at all on any of the three keywords.c
file. Looks cleaner overall.
Hopefully this is the last version of this patch.
--
Alvaro Herrera http://www.CommandPrompt.com/
PostgreSQL Replication, Consulting, Custom Development, 24x7 support
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/gram.y
===================================================================
RCS file: /home/alvherre/Code/cvs/pgsql/src/backend/parser/gram.y,v
retrieving revision 2.659
diff -c -p -r2.659 gram.y
*** src/backend/parser/gram.y 24 Feb 2009 10:06:33 -0000 2.659
--- src/backend/parser/gram.y 4 Mar 2009 17:04:39 -0000
*************** static TypeName *TableFuncTypeName(List
*** 423,429 ****
/*
* If you make any token changes, update the keyword table in
! * parser/keywords.c and add new keywords to the appropriate one of
* the reserved-or-not-so-reserved keyword lists, below; search
* this file for "Name classification hierarchy".
*/
--- 423,429 ----
/*
* If you make any token changes, update the keyword table in
! * src/include/parser/kwlist.h and add new keywords to the appropriate one of
* the reserved-or-not-so-reserved keyword lists, below; search
* this file for "Name classification hierarchy".
*/
*************** static TypeName *TableFuncTypeName(List
*** 516,522 ****
ZONE
! /* The grammar thinks these are keywords, but they are not in the keywords.c
* list and so can never be entered directly. The filter in parser.c
* creates these tokens when required.
*/
--- 516,522 ----
ZONE
! /* The grammar thinks these are keywords, but they are not in the kwlist.h
* list and so can never be entered directly. The filter in parser.c
* creates these tokens when required.
*/
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 17:02:19 -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) $(KEYWRDOBJS) $(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) $(KEYWRDOBJS) $(libpq_builddir)/libpq.a
! $(CC) $(CFLAGS) pg_restore.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $...@$(X)
+ pg_dumpall: pg_dumpall.o dumputils.o $(KEYWRDOBJS) $(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 17:38:28 -0000
***************
*** 0 ****
--- 1,26 ----
+ /*-------------------------------------------------------------------------
+ *
+ * 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"
+
+ #include "parser/keywords.h"
+
+ /*
+ * We don't need the token number, so leave it out to avoid requiring other
+ * backend headers.
+ */
+ #define PG_KEYWORD(a,b,c) {a,0,c}
+
+ #include "parser/kwlist.h"
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 5 Mar 2009 13:08:57 -0000
***************
*** 0 ****
--- 1,24 ----
+ /*-------------------------------------------------------------------------
+ *
+ * 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"
+
+ #include "parser/keywords.h"
+ #include "type.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
