mirror of
https://github.com/postgres/postgres.git
synced 2025-10-16 17:07:43 +03:00
Arrange for quote_identifier() and pg_dump to not quote keywords that are
unreserved according to the grammar. The list of unreserved words has gotten extensive enough that the unnecessary quoting is becoming a bit of an eyesore. To do this, add knowledge of the keyword category to keywords.c's table. (Someday we might be able to generate keywords.c's table and the keyword lists in gram.y from a common source.) For the moment, lie about WITH's status in the table so it will still get quoted --- this is because of the expectation that WITH will become reserved when the SQL recursive-queries patch gets done. I didn't force initdb because this affects nothing on-disk; but note that a few regression tests have changed expected output.
This commit is contained in:
Tom Lane
@@ -11,7 +11,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.594 2007/06/15 20:56:49 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.595 2007/06/18 21:40:57 tgl Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
@@ -8787,12 +8787,16 @@ ColLabel: IDENT { $$ = $1; }
|
||||
|
||||
|
||||
/*
|
||||
* Keyword classification lists. Generally, every keyword present in
|
||||
* Keyword category lists. Generally, every keyword present in
|
||||
* the Postgres grammar should appear in exactly one of these lists.
|
||||
*
|
||||
* Put a new keyword into the first list that it can go into without causing
|
||||
* shift or reduce conflicts. The earlier lists define "less reserved"
|
||||
* categories of keywords.
|
||||
*
|
||||
* Make sure that each keyword's category in keywords.c matches where
|
||||
* it is listed here. (Someday we may be able to generate these lists and
|
||||
* keywords.c's table from a common master list.)
|
||||
*/
|
||||
|
||||
/* "Unreserved" keywords --- available for use as any kind of name.
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* keywords.c
|
||||
* lexical token lookup for reserved words in PostgreSQL
|
||||
* lexical token lookup for key words in PostgreSQL
|
||||
*
|
||||
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.188 2007/06/11 01:16:25 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.189 2007/06/18 21:40:58 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -24,380 +24,388 @@
|
||||
/* NB: This file is also used by pg_dump. */
|
||||
|
||||
/*
|
||||
* List of (keyword-name, keyword-token-value) pairs.
|
||||
* List of keyword (name, token-value, category) entries.
|
||||
*
|
||||
* !!WARNING!!: This list must be sorted, because binary
|
||||
* !!WARNING!!: This list must be sorted by ASCII name, because binary
|
||||
* search is used to locate entries.
|
||||
*/
|
||||
static const ScanKeyword ScanKeywords[] = {
|
||||
/* name, value */
|
||||
{"abort", ABORT_P},
|
||||
{"absolute", ABSOLUTE_P},
|
||||
{"access", ACCESS},
|
||||
{"action", ACTION},
|
||||
{"add", ADD_P},
|
||||
{"admin", ADMIN},
|
||||
{"after", AFTER},
|
||||
{"aggregate", AGGREGATE},
|
||||
{"all", ALL},
|
||||
{"also", ALSO},
|
||||
{"alter", ALTER},
|
||||
{"always", ALWAYS},
|
||||
{"analyse", ANALYSE}, /* British spelling */
|
||||
{"analyze", ANALYZE},
|
||||
{"and", AND},
|
||||
{"any", ANY},
|
||||
{"array", ARRAY},
|
||||
{"as", AS},
|
||||
{"asc", ASC},
|
||||
{"assertion", ASSERTION},
|
||||
{"assignment", ASSIGNMENT},
|
||||
{"asymmetric", ASYMMETRIC},
|
||||
{"at", AT},
|
||||
{"authorization", AUTHORIZATION},
|
||||
{"backward", BACKWARD},
|
||||
{"before", BEFORE},
|
||||
{"begin", BEGIN_P},
|
||||
{"between", BETWEEN},
|
||||
{"bigint", BIGINT},
|
||||
{"binary", BINARY},
|
||||
{"bit", BIT},
|
||||
{"boolean", BOOLEAN_P},
|
||||
{"both", BOTH},
|
||||
{"by", BY},
|
||||
{"cache", CACHE},
|
||||
{"called", CALLED},
|
||||
{"cascade", CASCADE},
|
||||
{"cascaded", CASCADED},
|
||||
{"case", CASE},
|
||||
{"cast", CAST},
|
||||
{"chain", CHAIN},
|
||||
{"char", CHAR_P},
|
||||
{"character", CHARACTER},
|
||||
{"characteristics", CHARACTERISTICS},
|
||||
{"check", CHECK},
|
||||
{"checkpoint", CHECKPOINT},
|
||||
{"class", CLASS},
|
||||
{"close", CLOSE},
|
||||
{"cluster", CLUSTER},
|
||||
{"coalesce", COALESCE},
|
||||
{"collate", COLLATE},
|
||||
{"column", COLUMN},
|
||||
{"comment", COMMENT},
|
||||
{"commit", COMMIT},
|
||||
{"committed", COMMITTED},
|
||||
{"concurrently", CONCURRENTLY},
|
||||
{"connection", CONNECTION},
|
||||
{"constraint", CONSTRAINT},
|
||||
{"constraints", CONSTRAINTS},
|
||||
{"content", CONTENT_P},
|
||||
{"conversion", CONVERSION_P},
|
||||
{"convert", CONVERT},
|
||||
{"copy", COPY},
|
||||
{"cost", COST},
|
||||
{"create", CREATE},
|
||||
{"createdb", CREATEDB},
|
||||
{"createrole", CREATEROLE},
|
||||
{"createuser", CREATEUSER},
|
||||
{"cross", CROSS},
|
||||
{"csv", CSV},
|
||||
{"current", CURRENT_P},
|
||||
{"current_date", CURRENT_DATE},
|
||||
{"current_role", CURRENT_ROLE},
|
||||
{"current_time", CURRENT_TIME},
|
||||
{"current_timestamp", CURRENT_TIMESTAMP},
|
||||
{"current_user", CURRENT_USER},
|
||||
{"cursor", CURSOR},
|
||||
{"cycle", CYCLE},
|
||||
{"database", DATABASE},
|
||||
{"day", DAY_P},
|
||||
{"deallocate", DEALLOCATE},
|
||||
{"dec", DEC},
|
||||
{"decimal", DECIMAL_P},
|
||||
{"declare", DECLARE},
|
||||
{"default", DEFAULT},
|
||||
{"defaults", DEFAULTS},
|
||||
{"deferrable", DEFERRABLE},
|
||||
{"deferred", DEFERRED},
|
||||
{"definer", DEFINER},
|
||||
{"delete", DELETE_P},
|
||||
{"delimiter", DELIMITER},
|
||||
{"delimiters", DELIMITERS},
|
||||
{"desc", DESC},
|
||||
{"disable", DISABLE_P},
|
||||
{"discard", DISCARD},
|
||||
{"distinct", DISTINCT},
|
||||
{"do", DO},
|
||||
{"document", DOCUMENT_P},
|
||||
{"domain", DOMAIN_P},
|
||||
{"double", DOUBLE_P},
|
||||
{"drop", DROP},
|
||||
{"each", EACH},
|
||||
{"else", ELSE},
|
||||
{"enable", ENABLE_P},
|
||||
{"encoding", ENCODING},
|
||||
{"encrypted", ENCRYPTED},
|
||||
{"end", END_P},
|
||||
{"enum", ENUM_P},
|
||||
{"escape", ESCAPE},
|
||||
{"except", EXCEPT},
|
||||
{"excluding", EXCLUDING},
|
||||
{"exclusive", EXCLUSIVE},
|
||||
{"execute", EXECUTE},
|
||||
{"exists", EXISTS},
|
||||
{"explain", EXPLAIN},
|
||||
{"external", EXTERNAL},
|
||||
{"extract", EXTRACT},
|
||||
{"false", FALSE_P},
|
||||
{"family", FAMILY},
|
||||
{"fetch", FETCH},
|
||||
{"first", FIRST_P},
|
||||
{"float", FLOAT_P},
|
||||
{"for", FOR},
|
||||
{"force", FORCE},
|
||||
{"foreign", FOREIGN},
|
||||
{"forward", FORWARD},
|
||||
{"freeze", FREEZE},
|
||||
{"from", FROM},
|
||||
{"full", FULL},
|
||||
{"function", FUNCTION},
|
||||
{"global", GLOBAL},
|
||||
{"grant", GRANT},
|
||||
{"granted", GRANTED},
|
||||
{"greatest", GREATEST},
|
||||
{"group", GROUP_P},
|
||||
{"handler", HANDLER},
|
||||
{"having", HAVING},
|
||||
{"header", HEADER_P},
|
||||
{"hold", HOLD},
|
||||
{"hour", HOUR_P},
|
||||
{"if", IF_P},
|
||||
{"ilike", ILIKE},
|
||||
{"immediate", IMMEDIATE},
|
||||
{"immutable", IMMUTABLE},
|
||||
{"implicit", IMPLICIT_P},
|
||||
{"in", IN_P},
|
||||
{"including", INCLUDING},
|
||||
{"increment", INCREMENT},
|
||||
{"index", INDEX},
|
||||
{"indexes", INDEXES},
|
||||
{"inherit", INHERIT},
|
||||
{"inherits", INHERITS},
|
||||
{"initially", INITIALLY},
|
||||
{"inner", INNER_P},
|
||||
{"inout", INOUT},
|
||||
{"input", INPUT_P},
|
||||
{"insensitive", INSENSITIVE},
|
||||
{"insert", INSERT},
|
||||
{"instead", INSTEAD},
|
||||
{"int", INT_P},
|
||||
{"integer", INTEGER},
|
||||
{"intersect", INTERSECT},
|
||||
{"interval", INTERVAL},
|
||||
{"into", INTO},
|
||||
{"invoker", INVOKER},
|
||||
{"is", IS},
|
||||
{"isnull", ISNULL},
|
||||
{"isolation", ISOLATION},
|
||||
{"join", JOIN},
|
||||
{"key", KEY},
|
||||
{"lancompiler", LANCOMPILER},
|
||||
{"language", LANGUAGE},
|
||||
{"large", LARGE_P},
|
||||
{"last", LAST_P},
|
||||
{"leading", LEADING},
|
||||
{"least", LEAST},
|
||||
{"left", LEFT},
|
||||
{"level", LEVEL},
|
||||
{"like", LIKE},
|
||||
{"limit", LIMIT},
|
||||
{"listen", LISTEN},
|
||||
{"load", LOAD},
|
||||
{"local", LOCAL},
|
||||
{"localtime", LOCALTIME},
|
||||
{"localtimestamp", LOCALTIMESTAMP},
|
||||
{"location", LOCATION},
|
||||
{"lock", LOCK_P},
|
||||
{"login", LOGIN_P},
|
||||
{"match", MATCH},
|
||||
{"maxvalue", MAXVALUE},
|
||||
{"minute", MINUTE_P},
|
||||
{"minvalue", MINVALUE},
|
||||
{"mode", MODE},
|
||||
{"month", MONTH_P},
|
||||
{"move", MOVE},
|
||||
{"name", NAME_P},
|
||||
{"names", NAMES},
|
||||
{"national", NATIONAL},
|
||||
{"natural", NATURAL},
|
||||
{"nchar", NCHAR},
|
||||
{"new", NEW},
|
||||
{"next", NEXT},
|
||||
{"no", NO},
|
||||
{"nocreatedb", NOCREATEDB},
|
||||
{"nocreaterole", NOCREATEROLE},
|
||||
{"nocreateuser", NOCREATEUSER},
|
||||
{"noinherit", NOINHERIT},
|
||||
{"nologin", NOLOGIN_P},
|
||||
{"none", NONE},
|
||||
{"nosuperuser", NOSUPERUSER},
|
||||
{"not", NOT},
|
||||
{"nothing", NOTHING},
|
||||
{"notify", NOTIFY},
|
||||
{"notnull", NOTNULL},
|
||||
{"nowait", NOWAIT},
|
||||
{"null", NULL_P},
|
||||
{"nullif", NULLIF},
|
||||
{"nulls", NULLS_P},
|
||||
{"numeric", NUMERIC},
|
||||
{"object", OBJECT_P},
|
||||
{"of", OF},
|
||||
{"off", OFF},
|
||||
{"offset", OFFSET},
|
||||
{"oids", OIDS},
|
||||
{"old", OLD},
|
||||
{"on", ON},
|
||||
{"only", ONLY},
|
||||
{"operator", OPERATOR},
|
||||
{"option", OPTION},
|
||||
{"or", OR},
|
||||
{"order", ORDER},
|
||||
{"out", OUT_P},
|
||||
{"outer", OUTER_P},
|
||||
{"overlaps", OVERLAPS},
|
||||
{"overlay", OVERLAY},
|
||||
{"owned", OWNED},
|
||||
{"owner", OWNER},
|
||||
{"partial", PARTIAL},
|
||||
{"password", PASSWORD},
|
||||
{"placing", PLACING},
|
||||
{"plans", PLANS},
|
||||
{"position", POSITION},
|
||||
{"precision", PRECISION},
|
||||
{"prepare", PREPARE},
|
||||
{"prepared", PREPARED},
|
||||
{"preserve", PRESERVE},
|
||||
{"primary", PRIMARY},
|
||||
{"prior", PRIOR},
|
||||
{"privileges", PRIVILEGES},
|
||||
{"procedural", PROCEDURAL},
|
||||
{"procedure", PROCEDURE},
|
||||
{"quote", QUOTE},
|
||||
{"read", READ},
|
||||
{"real", REAL},
|
||||
{"reassign", REASSIGN},
|
||||
{"recheck", RECHECK},
|
||||
{"references", REFERENCES},
|
||||
{"reindex", REINDEX},
|
||||
{"relative", RELATIVE_P},
|
||||
{"release", RELEASE},
|
||||
{"rename", RENAME},
|
||||
{"repeatable", REPEATABLE},
|
||||
{"replace", REPLACE},
|
||||
{"replica", REPLICA},
|
||||
{"reset", RESET},
|
||||
{"restart", RESTART},
|
||||
{"restrict", RESTRICT},
|
||||
{"returning", RETURNING},
|
||||
{"returns", RETURNS},
|
||||
{"revoke", REVOKE},
|
||||
{"right", RIGHT},
|
||||
{"role", ROLE},
|
||||
{"rollback", ROLLBACK},
|
||||
{"row", ROW},
|
||||
{"rows", ROWS},
|
||||
{"rule", RULE},
|
||||
{"savepoint", SAVEPOINT},
|
||||
{"schema", SCHEMA},
|
||||
{"scroll", SCROLL},
|
||||
{"second", SECOND_P},
|
||||
{"security", SECURITY},
|
||||
{"select", SELECT},
|
||||
{"sequence", SEQUENCE},
|
||||
{"serializable", SERIALIZABLE},
|
||||
{"session", SESSION},
|
||||
{"session_user", SESSION_USER},
|
||||
{"set", SET},
|
||||
{"setof", SETOF},
|
||||
{"share", SHARE},
|
||||
{"show", SHOW},
|
||||
{"similar", SIMILAR},
|
||||
{"simple", SIMPLE},
|
||||
{"smallint", SMALLINT},
|
||||
{"some", SOME},
|
||||
{"stable", STABLE},
|
||||
{"standalone", STANDALONE_P},
|
||||
{"start", START},
|
||||
{"statement", STATEMENT},
|
||||
{"statistics", STATISTICS},
|
||||
{"stdin", STDIN},
|
||||
{"stdout", STDOUT},
|
||||
{"storage", STORAGE},
|
||||
{"strict", STRICT_P},
|
||||
{"strip", STRIP_P},
|
||||
{"substring", SUBSTRING},
|
||||
{"superuser", SUPERUSER_P},
|
||||
{"symmetric", SYMMETRIC},
|
||||
{"sysid", SYSID},
|
||||
{"system", SYSTEM_P},
|
||||
{"table", TABLE},
|
||||
{"tablespace", TABLESPACE},
|
||||
{"temp", TEMP},
|
||||
{"template", TEMPLATE},
|
||||
{"temporary", TEMPORARY},
|
||||
{"then", THEN},
|
||||
{"time", TIME},
|
||||
{"timestamp", TIMESTAMP},
|
||||
{"to", TO},
|
||||
{"trailing", TRAILING},
|
||||
{"transaction", TRANSACTION},
|
||||
{"treat", TREAT},
|
||||
{"trigger", TRIGGER},
|
||||
{"trim", TRIM},
|
||||
{"true", TRUE_P},
|
||||
{"truncate", TRUNCATE},
|
||||
{"trusted", TRUSTED},
|
||||
{"type", TYPE_P},
|
||||
{"uncommitted", UNCOMMITTED},
|
||||
{"unencrypted", UNENCRYPTED},
|
||||
{"union", UNION},
|
||||
{"unique", UNIQUE},
|
||||
{"unknown", UNKNOWN},
|
||||
{"unlisten", UNLISTEN},
|
||||
{"until", UNTIL},
|
||||
{"update", UPDATE},
|
||||
{"user", USER},
|
||||
{"using", USING},
|
||||
{"vacuum", VACUUM},
|
||||
{"valid", VALID},
|
||||
{"validator", VALIDATOR},
|
||||
{"value", VALUE_P},
|
||||
{"values", VALUES},
|
||||
{"varchar", VARCHAR},
|
||||
{"varying", VARYING},
|
||||
{"verbose", VERBOSE},
|
||||
{"version", VERSION_P},
|
||||
{"view", VIEW},
|
||||
{"volatile", VOLATILE},
|
||||
{"when", WHEN},
|
||||
{"where", WHERE},
|
||||
{"whitespace", WHITESPACE_P},
|
||||
{"with", WITH},
|
||||
{"without", WITHOUT},
|
||||
{"work", WORK},
|
||||
{"write", WRITE},
|
||||
{"xml", XML_P},
|
||||
{"xmlattributes", XMLATTRIBUTES},
|
||||
{"xmlconcat", XMLCONCAT},
|
||||
{"xmlelement", XMLELEMENT},
|
||||
{"xmlforest", XMLFOREST},
|
||||
{"xmlparse", XMLPARSE},
|
||||
{"xmlpi", XMLPI},
|
||||
{"xmlroot", XMLROOT},
|
||||
{"xmlserialize", XMLSERIALIZE},
|
||||
{"year", YEAR_P},
|
||||
{"yes", YES_P},
|
||||
{"zone", ZONE},
|
||||
/* 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},
|
||||
{"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},
|
||||
{"connection", CONNECTION, UNRESERVED_KEYWORD},
|
||||
{"constraint", CONSTRAINT, RESERVED_KEYWORD},
|
||||
{"constraints", CONSTRAINTS, UNRESERVED_KEYWORD},
|
||||
{"content", CONTENT_P, UNRESERVED_KEYWORD},
|
||||
{"conversion", CONVERSION_P, UNRESERVED_KEYWORD},
|
||||
{"convert", CONVERT, COL_NAME_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},
|
||||
{"current", CURRENT_P, UNRESERVED_KEYWORD},
|
||||
{"current_date", CURRENT_DATE, RESERVED_KEYWORD},
|
||||
{"current_role", CURRENT_ROLE, RESERVED_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},
|
||||
{"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},
|
||||
{"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, UNRESERVED_KEYWORD},
|
||||
{"first", FIRST_P, UNRESERVED_KEYWORD},
|
||||
{"float", FLOAT_P, COL_NAME_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},
|
||||
{"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},
|
||||
{"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},
|
||||
{"or", OR, RESERVED_KEYWORD},
|
||||
{"order", ORDER, RESERVED_KEYWORD},
|
||||
{"out", OUT_P, COL_NAME_KEYWORD},
|
||||
{"outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD},
|
||||
{"overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD},
|
||||
{"overlay", OVERLAY, COL_NAME_KEYWORD},
|
||||
{"owned", OWNED, UNRESERVED_KEYWORD},
|
||||
{"owner", OWNER, UNRESERVED_KEYWORD},
|
||||
{"partial", PARTIAL, UNRESERVED_KEYWORD},
|
||||
{"password", PASSWORD, UNRESERVED_KEYWORD},
|
||||
{"placing", PLACING, RESERVED_KEYWORD},
|
||||
{"plans", PLANS, UNRESERVED_KEYWORD},
|
||||
{"position", POSITION, COL_NAME_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},
|
||||
{"read", READ, UNRESERVED_KEYWORD},
|
||||
{"real", REAL, COL_NAME_KEYWORD},
|
||||
{"reassign", REASSIGN, UNRESERVED_KEYWORD},
|
||||
{"recheck", RECHECK, 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},
|
||||
{"second", SECOND_P, UNRESERVED_KEYWORD},
|
||||
{"security", SECURITY, UNRESERVED_KEYWORD},
|
||||
{"select", SELECT, RESERVED_KEYWORD},
|
||||
{"sequence", SEQUENCE, UNRESERVED_KEYWORD},
|
||||
{"serializable", SERIALIZABLE, 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},
|
||||
{"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},
|
||||
{"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},
|
||||
{"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},
|
||||
/*
|
||||
* XXX we mark WITH as reserved to force it to be quoted in dumps, even
|
||||
* though it is currently unreserved according to gram.y. This is because
|
||||
* we expect we'll have to make it reserved to implement SQL WITH clauses.
|
||||
* If that patch manages to do without reserving WITH, adjust this entry
|
||||
* at that time; in any case this should be back in sync with gram.y
|
||||
* after WITH clauses are implemented.
|
||||
*/
|
||||
{"with", WITH, RESERVED_KEYWORD},
|
||||
{"without", WITHOUT, UNRESERVED_KEYWORD},
|
||||
{"work", WORK, 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},
|
||||
};
|
||||
|
||||
/*
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.261 2007/06/11 22:22:42 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.262 2007/06/18 21:40:58 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -5175,15 +5175,16 @@ quote_identifier(const char *ident)
|
||||
if (safe)
|
||||
{
|
||||
/*
|
||||
* Check for keyword. This test is overly strong, since many of the
|
||||
* "keywords" known to the parser are usable as column names, but the
|
||||
* parser doesn't provide any easy way to test for whether an
|
||||
* identifier is safe or not... so be safe not sorry.
|
||||
* Check for keyword. We quote keywords except for unreserved ones.
|
||||
* (In some cases we could avoid quoting a col_name or type_func_name
|
||||
* keyword, but it seems much harder than it's worth to tell that.)
|
||||
*
|
||||
* Note: ScanKeywordLookup() does case-insensitive comparison, but
|
||||
* that's fine, since we already know we have all-lower-case.
|
||||
*/
|
||||
if (ScanKeywordLookup(ident) != NULL)
|
||||
const ScanKeyword *keyword = ScanKeywordLookup(ident);
|
||||
|
||||
if (keyword != NULL && keyword->category != UNRESERVED_KEYWORD)
|
||||
safe = false;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user