diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 8ec562c5e316c65b5f5072f3118f33929c1df5a1..6e894c1799a5858902826386ab3ea6811510920d 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -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.
diff --git a/src/backend/parser/keywords.c b/src/backend/parser/keywords.c
index b48a0c79583d8a0adc45587d21634060f7a123be..5b62a9c7c984cff95827afa24354b4d9c9318570 100644
--- a/src/backend/parser/keywords.c
+++ b/src/backend/parser/keywords.c
@@ -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},
};
/*
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 49c7821cef08a67334176d2db2daf81b0b4f7f97..df5dbec6078587d77ff249eb2a3843a7585a5b07 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -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;
}
diff --git a/src/bin/pg_dump/dumputils.c b/src/bin/pg_dump/dumputils.c
index c122aaad1aa6345a67e56972a18840c178a75a46..0fc42ca7c26b4f832506615b42a0a5aad1777d30 100644
--- a/src/bin/pg_dump/dumputils.c
+++ b/src/bin/pg_dump/dumputils.c
@@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/bin/pg_dump/dumputils.c,v 1.35 2007/01/05 22:19:48 momjian Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/dumputils.c,v 1.36 2007/06/18 21:40:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -53,11 +53,8 @@ fmtId(const char *rawid)
* These checks need to match the identifier production in scan.l. Don't
* use islower() etc.
*/
-
- if (ScanKeywordLookup(rawid))
- need_quotes = true;
/* slightly different rules for first character */
- else if (!((rawid[0] >= 'a' && rawid[0] <= 'z') || rawid[0] == '_'))
+ if (!((rawid[0] >= 'a' && rawid[0] <= 'z') || rawid[0] == '_'))
need_quotes = true;
else
{
@@ -74,6 +71,22 @@ fmtId(const char *rawid)
}
}
+ if (!need_quotes)
+ {
+ /*
+ * 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.
+ */
+ const ScanKeyword *keyword = ScanKeywordLookup(rawid);
+
+ if (keyword != NULL && keyword->category != UNRESERVED_KEYWORD)
+ need_quotes = true;
+ }
+
if (!need_quotes)
{
/* no quoting needed */
diff --git a/src/include/parser/keywords.h b/src/include/parser/keywords.h
index d16b5374a98c6553563d2920e6dd5f714bdce7bf..4cb37e5288ddf8fa350c0bc81403076ec1de2ccf 100644
--- a/src/include/parser/keywords.h
+++ b/src/include/parser/keywords.h
@@ -1,23 +1,31 @@
/*-------------------------------------------------------------------------
*
* keywords.h
- * lexical token lookup for reserved words in postgres SQL
+ * 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
*
- * $PostgreSQL: pgsql/src/include/parser/keywords.h,v 1.22 2007/01/05 22:19:56 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/parser/keywords.h,v 1.23 2007/06/18 21:40:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef KEYWORDS_H
#define KEYWORDS_H
+/* Keyword categories --- should match lists in gram.y */
+#define UNRESERVED_KEYWORD 0
+#define COL_NAME_KEYWORD 1
+#define TYPE_FUNC_NAME_KEYWORD 2
+#define RESERVED_KEYWORD 3
+
+
typedef struct ScanKeyword
{
- const char *name;
- int value;
+ const char *name; /* in lower case */
+ int16 value; /* grammar's token code */
+ int16 category; /* see codes above */
} ScanKeyword;
extern const ScanKeyword *ScanKeywordLookup(const char *text);
diff --git a/src/test/regress/expected/prepare.out b/src/test/regress/expected/prepare.out
index 626b951bc310bb8be9255e5d7260f56e5c44b66f..35e1befcbb49998f803d72d14fb3ed2e0916fc19 100644
--- a/src/test/regress/expected/prepare.out
+++ b/src/test/regress/expected/prepare.out
@@ -164,7 +164,7 @@ SELECT name, statement, parameter_types FROM pg_prepared_statements
q5 | PREPARE q5(int, text) AS | {integer,text}
: \x09SELECT * FROM tenk1 WHERE unique1 = $1 OR stringu1 = $2
: \x09ORDER BY unique1;
- q6 | PREPARE q6 AS | {integer,"\"name\""}
+ q6 | PREPARE q6 AS | {integer,name}
: SELECT * FROM tenk1 WHERE unique1 = $1 AND stringu1 = $2;
q7 | PREPARE q7(unknown) AS | {path}
: SELECT * FROM road WHERE thepath = $1;
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index e1098fd68456d5da100b2e674fd19c26cccbdb4c..00e60aad4cc501fdcf66a163e784a166615acf10 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1278,39 +1278,39 @@ drop table cchild;
SELECT viewname, definition FROM pg_views WHERE schemaname <> 'information_schema' ORDER BY viewname;
viewname | definition
--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- iexit | SELECT ih."name", ih.thepath, interpt_pp(ih.thepath, r.thepath) AS exit FROM ihighway ih, ramp r WHERE (ih.thepath ## r.thepath);
- pg_cursors | SELECT c."name", c."statement", c.is_holdable, c.is_binary, c.is_scrollable, c.creation_time FROM pg_cursor() c("name" text, "statement" text, is_holdable boolean, is_binary boolean, is_scrollable boolean, creation_time timestamp with time zone);
+ iexit | SELECT ih.name, ih.thepath, interpt_pp(ih.thepath, r.thepath) AS exit FROM ihighway ih, ramp r WHERE (ih.thepath ## r.thepath);
+ pg_cursors | SELECT c.name, c.statement, c.is_holdable, c.is_binary, c.is_scrollable, c.creation_time FROM pg_cursor() c(name text, statement text, is_holdable boolean, is_binary boolean, is_scrollable boolean, creation_time timestamp with time zone);
pg_group | SELECT pg_authid.rolname AS groname, pg_authid.oid AS grosysid, ARRAY(SELECT pg_auth_members.member FROM pg_auth_members WHERE (pg_auth_members.roleid = pg_authid.oid)) AS grolist FROM pg_authid WHERE (NOT pg_authid.rolcanlogin);
- pg_indexes | SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, t.spcname AS "tablespace", pg_get_indexdef(i.oid) AS indexdef FROM ((((pg_index x JOIN pg_class c ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = i.reltablespace))) WHERE ((c.relkind = 'r'::"char") AND (i.relkind = 'i'::"char"));
- pg_locks | SELECT l.locktype, l."database", l.relation, l.page, l.tuple, l.transactionid, l.classid, l.objid, l.objsubid, l."transaction", l.pid, l."mode", l."granted" FROM pg_lock_status() l(locktype text, "database" oid, relation oid, page integer, tuple smallint, transactionid xid, classid oid, objid oid, objsubid smallint, "transaction" xid, pid integer, "mode" text, "granted" boolean);
- pg_prepared_statements | SELECT p."name", p."statement", p.prepare_time, p.parameter_types, p.from_sql FROM pg_prepared_statement() p("name" text, "statement" text, prepare_time timestamp with time zone, parameter_types regtype[], from_sql boolean);
- pg_prepared_xacts | SELECT p."transaction", p.gid, p."prepared", u.rolname AS "owner", d.datname AS "database" FROM ((pg_prepared_xact() p("transaction" xid, gid text, "prepared" timestamp with time zone, ownerid oid, dbid oid) LEFT JOIN pg_authid u ON ((p.ownerid = u.oid))) LEFT JOIN pg_database d ON ((p.dbid = d.oid)));
+ pg_indexes | SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, t.spcname AS tablespace, pg_get_indexdef(i.oid) AS indexdef FROM ((((pg_index x JOIN pg_class c ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = i.reltablespace))) WHERE ((c.relkind = 'r'::"char") AND (i.relkind = 'i'::"char"));
+ pg_locks | SELECT l.locktype, l.database, l.relation, l.page, l.tuple, l.transactionid, l.classid, l.objid, l.objsubid, l.transaction, l.pid, l.mode, l.granted FROM pg_lock_status() l(locktype text, database oid, relation oid, page integer, tuple smallint, transactionid xid, classid oid, objid oid, objsubid smallint, transaction xid, pid integer, mode text, granted boolean);
+ pg_prepared_statements | SELECT p.name, p.statement, p.prepare_time, p.parameter_types, p.from_sql FROM pg_prepared_statement() p(name text, statement text, prepare_time timestamp with time zone, parameter_types regtype[], from_sql boolean);
+ pg_prepared_xacts | SELECT p.transaction, p.gid, p.prepared, u.rolname AS owner, d.datname AS database FROM ((pg_prepared_xact() p(transaction xid, gid text, prepared timestamp with time zone, ownerid oid, dbid oid) LEFT JOIN pg_authid u ON ((p.ownerid = u.oid))) LEFT JOIN pg_database d ON ((p.dbid = d.oid)));
pg_roles | SELECT pg_authid.rolname, pg_authid.rolsuper, pg_authid.rolinherit, pg_authid.rolcreaterole, pg_authid.rolcreatedb, pg_authid.rolcatupdate, pg_authid.rolcanlogin, pg_authid.rolconnlimit, '********'::text AS rolpassword, pg_authid.rolvaliduntil, pg_authid.rolconfig, pg_authid.oid FROM pg_authid;
- pg_rules | SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::"name");
- pg_settings | SELECT a."name", a.setting, a.unit, a.category, a.short_desc, a.extra_desc, a.context, a.vartype, a.source, a.min_val, a.max_val FROM pg_show_all_settings() a("name" text, setting text, unit text, category text, short_desc text, extra_desc text, context text, vartype text, source text, min_val text, max_val text);
+ pg_rules | SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::name);
+ pg_settings | SELECT a.name, a.setting, a.unit, a.category, a.short_desc, a.extra_desc, a.context, a.vartype, a.source, a.min_val, a.max_val FROM pg_show_all_settings() a(name text, setting text, unit text, category text, short_desc text, extra_desc text, context text, vartype text, source text, min_val text, max_val text);
pg_shadow | SELECT pg_authid.rolname AS usename, pg_authid.oid AS usesysid, pg_authid.rolcreatedb AS usecreatedb, pg_authid.rolsuper AS usesuper, pg_authid.rolcatupdate AS usecatupd, pg_authid.rolpassword AS passwd, (pg_authid.rolvaliduntil)::abstime AS valuntil, pg_authid.rolconfig AS useconfig FROM pg_authid WHERE pg_authid.rolcanlogin;
pg_stat_activity | SELECT d.oid AS datid, d.datname, pg_stat_get_backend_pid(s.backendid) AS procpid, pg_stat_get_backend_userid(s.backendid) AS usesysid, u.rolname AS usename, pg_stat_get_backend_activity(s.backendid) AS current_query, pg_stat_get_backend_waiting(s.backendid) AS waiting, pg_stat_get_backend_txn_start(s.backendid) AS txn_start, pg_stat_get_backend_activity_start(s.backendid) AS query_start, pg_stat_get_backend_start(s.backendid) AS backend_start, pg_stat_get_backend_client_addr(s.backendid) AS client_addr, pg_stat_get_backend_client_port(s.backendid) AS client_port FROM pg_database d, (SELECT pg_stat_get_backend_idset() AS backendid) s, pg_authid u WHERE ((pg_stat_get_backend_dbid(s.backendid) = d.oid) AND (pg_stat_get_backend_userid(s.backendid) = u.oid));
pg_stat_all_indexes | SELECT c.oid AS relid, i.oid AS indexrelid, n.nspname AS schemaname, c.relname, i.relname AS indexrelname, pg_stat_get_numscans(i.oid) AS idx_scan, pg_stat_get_tuples_returned(i.oid) AS idx_tup_read, pg_stat_get_tuples_fetched(i.oid) AS idx_tup_fetch FROM (((pg_class c JOIN pg_index x ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char"]));
pg_stat_all_tables | SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, pg_stat_get_numscans(c.oid) AS seq_scan, pg_stat_get_tuples_returned(c.oid) AS seq_tup_read, (sum(pg_stat_get_numscans(i.indexrelid)))::bigint AS idx_scan, ((sum(pg_stat_get_tuples_fetched(i.indexrelid)))::bigint + pg_stat_get_tuples_fetched(c.oid)) AS idx_tup_fetch, pg_stat_get_tuples_inserted(c.oid) AS n_tup_ins, pg_stat_get_tuples_updated(c.oid) AS n_tup_upd, pg_stat_get_tuples_deleted(c.oid) AS n_tup_del, pg_stat_get_live_tuples(c.oid) AS n_live_tup, pg_stat_get_dead_tuples(c.oid) AS n_dead_tup, pg_stat_get_last_vacuum_time(c.oid) AS last_vacuum, pg_stat_get_last_autovacuum_time(c.oid) AS last_autovacuum, pg_stat_get_last_analyze_time(c.oid) AS last_analyze, pg_stat_get_last_autoanalyze_time(c.oid) AS last_autoanalyze FROM ((pg_class c LEFT JOIN pg_index i ON ((c.oid = i.indrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char"])) GROUP BY c.oid, n.nspname, c.relname;
pg_stat_bgwriter | SELECT pg_stat_get_bgwriter_timed_checkpoints() AS checkpoints_timed, pg_stat_get_bgwriter_requested_checkpoints() AS checkpoints_req, pg_stat_get_bgwriter_buf_written_checkpoints() AS buffers_checkpoint, pg_stat_get_bgwriter_buf_written_lru() AS buffers_lru, pg_stat_get_bgwriter_buf_written_all() AS buffers_all, pg_stat_get_bgwriter_maxwritten_lru() AS maxwritten_lru, pg_stat_get_bgwriter_maxwritten_all() AS maxwritten_all;
pg_stat_database | SELECT d.oid AS datid, d.datname, pg_stat_get_db_numbackends(d.oid) AS numbackends, pg_stat_get_db_xact_commit(d.oid) AS xact_commit, pg_stat_get_db_xact_rollback(d.oid) AS xact_rollback, (pg_stat_get_db_blocks_fetched(d.oid) - pg_stat_get_db_blocks_hit(d.oid)) AS blks_read, pg_stat_get_db_blocks_hit(d.oid) AS blks_hit, pg_stat_get_db_tuples_returned(d.oid) AS tup_returned, pg_stat_get_db_tuples_fetched(d.oid) AS tup_fetched, pg_stat_get_db_tuples_inserted(d.oid) AS tup_inserted, pg_stat_get_db_tuples_updated(d.oid) AS tup_updated, pg_stat_get_db_tuples_deleted(d.oid) AS tup_deleted FROM pg_database d;
- pg_stat_sys_indexes | SELECT pg_stat_all_indexes.relid, pg_stat_all_indexes.indexrelid, pg_stat_all_indexes.schemaname, pg_stat_all_indexes.relname, pg_stat_all_indexes.indexrelname, pg_stat_all_indexes.idx_scan, pg_stat_all_indexes.idx_tup_read, pg_stat_all_indexes.idx_tup_fetch FROM pg_stat_all_indexes WHERE (pg_stat_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_stat_sys_tables | SELECT pg_stat_all_tables.relid, pg_stat_all_tables.schemaname, pg_stat_all_tables.relname, pg_stat_all_tables.seq_scan, pg_stat_all_tables.seq_tup_read, pg_stat_all_tables.idx_scan, pg_stat_all_tables.idx_tup_fetch, pg_stat_all_tables.n_tup_ins, pg_stat_all_tables.n_tup_upd, pg_stat_all_tables.n_tup_del, pg_stat_all_tables.n_live_tup, pg_stat_all_tables.n_dead_tup, pg_stat_all_tables.last_vacuum, pg_stat_all_tables.last_autovacuum, pg_stat_all_tables.last_analyze, pg_stat_all_tables.last_autoanalyze FROM pg_stat_all_tables WHERE (pg_stat_all_tables.schemaname = ANY (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_stat_user_indexes | SELECT pg_stat_all_indexes.relid, pg_stat_all_indexes.indexrelid, pg_stat_all_indexes.schemaname, pg_stat_all_indexes.relname, pg_stat_all_indexes.indexrelname, pg_stat_all_indexes.idx_scan, pg_stat_all_indexes.idx_tup_read, pg_stat_all_indexes.idx_tup_fetch FROM pg_stat_all_indexes WHERE (pg_stat_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_stat_user_tables | SELECT pg_stat_all_tables.relid, pg_stat_all_tables.schemaname, pg_stat_all_tables.relname, pg_stat_all_tables.seq_scan, pg_stat_all_tables.seq_tup_read, pg_stat_all_tables.idx_scan, pg_stat_all_tables.idx_tup_fetch, pg_stat_all_tables.n_tup_ins, pg_stat_all_tables.n_tup_upd, pg_stat_all_tables.n_tup_del, pg_stat_all_tables.n_live_tup, pg_stat_all_tables.n_dead_tup, pg_stat_all_tables.last_vacuum, pg_stat_all_tables.last_autovacuum, pg_stat_all_tables.last_analyze, pg_stat_all_tables.last_autoanalyze FROM pg_stat_all_tables WHERE (pg_stat_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
+ pg_stat_sys_indexes | SELECT pg_stat_all_indexes.relid, pg_stat_all_indexes.indexrelid, pg_stat_all_indexes.schemaname, pg_stat_all_indexes.relname, pg_stat_all_indexes.indexrelname, pg_stat_all_indexes.idx_scan, pg_stat_all_indexes.idx_tup_read, pg_stat_all_indexes.idx_tup_fetch FROM pg_stat_all_indexes WHERE (pg_stat_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_stat_sys_tables | SELECT pg_stat_all_tables.relid, pg_stat_all_tables.schemaname, pg_stat_all_tables.relname, pg_stat_all_tables.seq_scan, pg_stat_all_tables.seq_tup_read, pg_stat_all_tables.idx_scan, pg_stat_all_tables.idx_tup_fetch, pg_stat_all_tables.n_tup_ins, pg_stat_all_tables.n_tup_upd, pg_stat_all_tables.n_tup_del, pg_stat_all_tables.n_live_tup, pg_stat_all_tables.n_dead_tup, pg_stat_all_tables.last_vacuum, pg_stat_all_tables.last_autovacuum, pg_stat_all_tables.last_analyze, pg_stat_all_tables.last_autoanalyze FROM pg_stat_all_tables WHERE (pg_stat_all_tables.schemaname = ANY (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_stat_user_indexes | SELECT pg_stat_all_indexes.relid, pg_stat_all_indexes.indexrelid, pg_stat_all_indexes.schemaname, pg_stat_all_indexes.relname, pg_stat_all_indexes.indexrelname, pg_stat_all_indexes.idx_scan, pg_stat_all_indexes.idx_tup_read, pg_stat_all_indexes.idx_tup_fetch FROM pg_stat_all_indexes WHERE (pg_stat_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_stat_user_tables | SELECT pg_stat_all_tables.relid, pg_stat_all_tables.schemaname, pg_stat_all_tables.relname, pg_stat_all_tables.seq_scan, pg_stat_all_tables.seq_tup_read, pg_stat_all_tables.idx_scan, pg_stat_all_tables.idx_tup_fetch, pg_stat_all_tables.n_tup_ins, pg_stat_all_tables.n_tup_upd, pg_stat_all_tables.n_tup_del, pg_stat_all_tables.n_live_tup, pg_stat_all_tables.n_dead_tup, pg_stat_all_tables.last_vacuum, pg_stat_all_tables.last_autovacuum, pg_stat_all_tables.last_analyze, pg_stat_all_tables.last_autoanalyze FROM pg_stat_all_tables WHERE (pg_stat_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
pg_statio_all_indexes | SELECT c.oid AS relid, i.oid AS indexrelid, n.nspname AS schemaname, c.relname, i.relname AS indexrelname, (pg_stat_get_blocks_fetched(i.oid) - pg_stat_get_blocks_hit(i.oid)) AS idx_blks_read, pg_stat_get_blocks_hit(i.oid) AS idx_blks_hit FROM (((pg_class c JOIN pg_index x ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char"]));
pg_statio_all_sequences | SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, (pg_stat_get_blocks_fetched(c.oid) - pg_stat_get_blocks_hit(c.oid)) AS blks_read, pg_stat_get_blocks_hit(c.oid) AS blks_hit FROM (pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'S'::"char");
pg_statio_all_tables | SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, (pg_stat_get_blocks_fetched(c.oid) - pg_stat_get_blocks_hit(c.oid)) AS heap_blks_read, pg_stat_get_blocks_hit(c.oid) AS heap_blks_hit, (sum((pg_stat_get_blocks_fetched(i.indexrelid) - pg_stat_get_blocks_hit(i.indexrelid))))::bigint AS idx_blks_read, (sum(pg_stat_get_blocks_hit(i.indexrelid)))::bigint AS idx_blks_hit, (pg_stat_get_blocks_fetched(t.oid) - pg_stat_get_blocks_hit(t.oid)) AS toast_blks_read, pg_stat_get_blocks_hit(t.oid) AS toast_blks_hit, (pg_stat_get_blocks_fetched(x.oid) - pg_stat_get_blocks_hit(x.oid)) AS tidx_blks_read, pg_stat_get_blocks_hit(x.oid) AS tidx_blks_hit FROM ((((pg_class c LEFT JOIN pg_index i ON ((c.oid = i.indrelid))) LEFT JOIN pg_class t ON ((c.reltoastrelid = t.oid))) LEFT JOIN pg_class x ON ((t.reltoastidxid = x.oid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char"])) GROUP BY c.oid, n.nspname, c.relname, t.oid, x.oid;
- pg_statio_sys_indexes | SELECT pg_statio_all_indexes.relid, pg_statio_all_indexes.indexrelid, pg_statio_all_indexes.schemaname, pg_statio_all_indexes.relname, pg_statio_all_indexes.indexrelname, pg_statio_all_indexes.idx_blks_read, pg_statio_all_indexes.idx_blks_hit FROM pg_statio_all_indexes WHERE (pg_statio_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_statio_sys_sequences | SELECT pg_statio_all_sequences.relid, pg_statio_all_sequences.schemaname, pg_statio_all_sequences.relname, pg_statio_all_sequences.blks_read, pg_statio_all_sequences.blks_hit FROM pg_statio_all_sequences WHERE (pg_statio_all_sequences.schemaname = ANY (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_statio_sys_tables | SELECT pg_statio_all_tables.relid, pg_statio_all_tables.schemaname, pg_statio_all_tables.relname, pg_statio_all_tables.heap_blks_read, pg_statio_all_tables.heap_blks_hit, pg_statio_all_tables.idx_blks_read, pg_statio_all_tables.idx_blks_hit, pg_statio_all_tables.toast_blks_read, pg_statio_all_tables.toast_blks_hit, pg_statio_all_tables.tidx_blks_read, pg_statio_all_tables.tidx_blks_hit FROM pg_statio_all_tables WHERE (pg_statio_all_tables.schemaname = ANY (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_statio_user_indexes | SELECT pg_statio_all_indexes.relid, pg_statio_all_indexes.indexrelid, pg_statio_all_indexes.schemaname, pg_statio_all_indexes.relname, pg_statio_all_indexes.indexrelname, pg_statio_all_indexes.idx_blks_read, pg_statio_all_indexes.idx_blks_hit FROM pg_statio_all_indexes WHERE (pg_statio_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_statio_user_sequences | SELECT pg_statio_all_sequences.relid, pg_statio_all_sequences.schemaname, pg_statio_all_sequences.relname, pg_statio_all_sequences.blks_read, pg_statio_all_sequences.blks_hit FROM pg_statio_all_sequences WHERE (pg_statio_all_sequences.schemaname <> ALL (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
- pg_statio_user_tables | SELECT pg_statio_all_tables.relid, pg_statio_all_tables.schemaname, pg_statio_all_tables.relname, pg_statio_all_tables.heap_blks_read, pg_statio_all_tables.heap_blks_hit, pg_statio_all_tables.idx_blks_read, pg_statio_all_tables.idx_blks_hit, pg_statio_all_tables.toast_blks_read, pg_statio_all_tables.toast_blks_hit, pg_statio_all_tables.tidx_blks_read, pg_statio_all_tables.tidx_blks_hit FROM pg_statio_all_tables WHERE (pg_statio_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::"name", 'pg_toast'::"name", 'information_schema'::"name"]));
+ pg_statio_sys_indexes | SELECT pg_statio_all_indexes.relid, pg_statio_all_indexes.indexrelid, pg_statio_all_indexes.schemaname, pg_statio_all_indexes.relname, pg_statio_all_indexes.indexrelname, pg_statio_all_indexes.idx_blks_read, pg_statio_all_indexes.idx_blks_hit FROM pg_statio_all_indexes WHERE (pg_statio_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_statio_sys_sequences | SELECT pg_statio_all_sequences.relid, pg_statio_all_sequences.schemaname, pg_statio_all_sequences.relname, pg_statio_all_sequences.blks_read, pg_statio_all_sequences.blks_hit FROM pg_statio_all_sequences WHERE (pg_statio_all_sequences.schemaname = ANY (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_statio_sys_tables | SELECT pg_statio_all_tables.relid, pg_statio_all_tables.schemaname, pg_statio_all_tables.relname, pg_statio_all_tables.heap_blks_read, pg_statio_all_tables.heap_blks_hit, pg_statio_all_tables.idx_blks_read, pg_statio_all_tables.idx_blks_hit, pg_statio_all_tables.toast_blks_read, pg_statio_all_tables.toast_blks_hit, pg_statio_all_tables.tidx_blks_read, pg_statio_all_tables.tidx_blks_hit FROM pg_statio_all_tables WHERE (pg_statio_all_tables.schemaname = ANY (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_statio_user_indexes | SELECT pg_statio_all_indexes.relid, pg_statio_all_indexes.indexrelid, pg_statio_all_indexes.schemaname, pg_statio_all_indexes.relname, pg_statio_all_indexes.indexrelname, pg_statio_all_indexes.idx_blks_read, pg_statio_all_indexes.idx_blks_hit FROM pg_statio_all_indexes WHERE (pg_statio_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_statio_user_sequences | SELECT pg_statio_all_sequences.relid, pg_statio_all_sequences.schemaname, pg_statio_all_sequences.relname, pg_statio_all_sequences.blks_read, pg_statio_all_sequences.blks_hit FROM pg_statio_all_sequences WHERE (pg_statio_all_sequences.schemaname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
+ pg_statio_user_tables | SELECT pg_statio_all_tables.relid, pg_statio_all_tables.schemaname, pg_statio_all_tables.relname, pg_statio_all_tables.heap_blks_read, pg_statio_all_tables.heap_blks_hit, pg_statio_all_tables.idx_blks_read, pg_statio_all_tables.idx_blks_hit, pg_statio_all_tables.toast_blks_read, pg_statio_all_tables.toast_blks_hit, pg_statio_all_tables.tidx_blks_read, pg_statio_all_tables.tidx_blks_hit FROM pg_statio_all_tables WHERE (pg_statio_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::name, 'pg_toast'::name, 'information_schema'::name]));
pg_stats | SELECT n.nspname AS schemaname, c.relname AS tablename, a.attname, s.stanullfrac AS null_frac, s.stawidth AS avg_width, s.stadistinct AS n_distinct, CASE 1 WHEN s.stakind1 THEN s.stavalues1 WHEN s.stakind2 THEN s.stavalues2 WHEN s.stakind3 THEN s.stavalues3 WHEN s.stakind4 THEN s.stavalues4 ELSE NULL::anyarray END AS most_common_vals, CASE 1 WHEN s.stakind1 THEN s.stanumbers1 WHEN s.stakind2 THEN s.stanumbers2 WHEN s.stakind3 THEN s.stanumbers3 WHEN s.stakind4 THEN s.stanumbers4 ELSE NULL::real[] END AS most_common_freqs, CASE 2 WHEN s.stakind1 THEN s.stavalues1 WHEN s.stakind2 THEN s.stavalues2 WHEN s.stakind3 THEN s.stavalues3 WHEN s.stakind4 THEN s.stavalues4 ELSE NULL::anyarray END AS histogram_bounds, CASE 3 WHEN s.stakind1 THEN s.stanumbers1[1] WHEN s.stakind2 THEN s.stanumbers2[1] WHEN s.stakind3 THEN s.stanumbers3[1] WHEN s.stakind4 THEN s.stanumbers4[1] ELSE NULL::real END AS correlation FROM (((pg_statistic s JOIN pg_class c ON ((c.oid = s.starelid))) JOIN pg_attribute a ON (((c.oid = a.attrelid) AND (a.attnum = s.staattnum)))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE has_table_privilege(c.oid, 'select'::text);
- pg_tables | SELECT n.nspname AS schemaname, c.relname AS tablename, pg_get_userbyid(c.relowner) AS tableowner, t.spcname AS "tablespace", c.relhasindex AS hasindexes, c.relhasrules AS hasrules, (c.reltriggers > 0) AS hastriggers FROM ((pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = c.reltablespace))) WHERE (c.relkind = 'r'::"char");
+ pg_tables | SELECT n.nspname AS schemaname, c.relname AS tablename, pg_get_userbyid(c.relowner) AS tableowner, t.spcname AS tablespace, c.relhasindex AS hasindexes, c.relhasrules AS hasrules, (c.reltriggers > 0) AS hastriggers FROM ((pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = c.reltablespace))) WHERE (c.relkind = 'r'::"char");
pg_timezone_abbrevs | SELECT pg_timezone_abbrevs.abbrev, pg_timezone_abbrevs.utc_offset, pg_timezone_abbrevs.is_dst FROM pg_timezone_abbrevs() pg_timezone_abbrevs(abbrev, utc_offset, is_dst);
- pg_timezone_names | SELECT pg_timezone_names."name", pg_timezone_names.abbrev, pg_timezone_names.utc_offset, pg_timezone_names.is_dst FROM pg_timezone_names() pg_timezone_names("name", abbrev, utc_offset, is_dst);
+ pg_timezone_names | SELECT pg_timezone_names.name, pg_timezone_names.abbrev, pg_timezone_names.utc_offset, pg_timezone_names.is_dst FROM pg_timezone_names() pg_timezone_names(name, abbrev, utc_offset, is_dst);
pg_user | SELECT pg_shadow.usename, pg_shadow.usesysid, pg_shadow.usecreatedb, pg_shadow.usesuper, pg_shadow.usecatupd, '********'::text AS passwd, pg_shadow.valuntil, pg_shadow.useconfig FROM pg_shadow;
pg_views | SELECT n.nspname AS schemaname, c.relname AS viewname, pg_get_userbyid(c.relowner) AS viewowner, pg_get_viewdef(c.oid) AS definition FROM (pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'v'::"char");
rtest_v1 | SELECT rtest_t1.a, rtest_t1.b FROM rtest_t1;
@@ -1325,19 +1325,19 @@ SELECT viewname, definition FROM pg_views WHERE schemaname <> 'information_schem
shoelace | SELECT s.sl_name, s.sl_avail, s.sl_color, s.sl_len, s.sl_unit, (s.sl_len * u.un_fact) AS sl_len_cm FROM shoelace_data s, unit u WHERE (s.sl_unit = u.un_name);
shoelace_candelete | SELECT shoelace_obsolete.sl_name, shoelace_obsolete.sl_avail, shoelace_obsolete.sl_color, shoelace_obsolete.sl_len, shoelace_obsolete.sl_unit, shoelace_obsolete.sl_len_cm FROM shoelace_obsolete WHERE (shoelace_obsolete.sl_avail = 0);
shoelace_obsolete | SELECT shoelace.sl_name, shoelace.sl_avail, shoelace.sl_color, shoelace.sl_len, shoelace.sl_unit, shoelace.sl_len_cm FROM shoelace WHERE (NOT (EXISTS (SELECT shoe.shoename FROM shoe WHERE (shoe.slcolor = shoelace.sl_color))));
- street | SELECT r."name", r.thepath, c.cname FROM ONLY road r, real_city c WHERE (c.outline ## r.thepath);
- toyemp | SELECT emp."name", emp.age, emp."location", (12 * emp.salary) AS annualsal FROM emp;
+ street | SELECT r.name, r.thepath, c.cname FROM ONLY road r, real_city c WHERE (c.outline ## r.thepath);
+ toyemp | SELECT emp.name, emp.age, emp.location, (12 * emp.salary) AS annualsal FROM emp;
(49 rows)
SELECT tablename, rulename, definition FROM pg_rules
ORDER BY tablename, rulename;
- tablename | rulename | definition
----------------+-----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ tablename | rulename | definition
+---------------+-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
pg_settings | pg_settings_n | CREATE RULE pg_settings_n AS ON UPDATE TO pg_settings DO INSTEAD NOTHING;
- pg_settings | pg_settings_u | CREATE RULE pg_settings_u AS ON UPDATE TO pg_settings WHERE (new."name" = old."name") DO SELECT set_config(old."name", new.setting, false) AS set_config;
- rtest_emp | rtest_emp_del | CREATE RULE rtest_emp_del AS ON DELETE TO rtest_emp DO INSERT INTO rtest_emplog (ename, who, "action", newsal, oldsal) VALUES (old.ename, "current_user"(), 'fired'::bpchar, '$0.00'::money, old.salary);
- rtest_emp | rtest_emp_ins | CREATE RULE rtest_emp_ins AS ON INSERT TO rtest_emp DO INSERT INTO rtest_emplog (ename, who, "action", newsal, oldsal) VALUES (new.ename, "current_user"(), 'hired'::bpchar, new.salary, '$0.00'::money);
- rtest_emp | rtest_emp_upd | CREATE RULE rtest_emp_upd AS ON UPDATE TO rtest_emp WHERE (new.salary <> old.salary) DO INSERT INTO rtest_emplog (ename, who, "action", newsal, oldsal) VALUES (new.ename, "current_user"(), 'honored'::bpchar, new.salary, old.salary);
+ pg_settings | pg_settings_u | CREATE RULE pg_settings_u AS ON UPDATE TO pg_settings WHERE (new.name = old.name) DO SELECT set_config(old.name, new.setting, false) AS set_config;
+ rtest_emp | rtest_emp_del | CREATE RULE rtest_emp_del AS ON DELETE TO rtest_emp DO INSERT INTO rtest_emplog (ename, who, action, newsal, oldsal) VALUES (old.ename, "current_user"(), 'fired'::bpchar, '$0.00'::money, old.salary);
+ rtest_emp | rtest_emp_ins | CREATE RULE rtest_emp_ins AS ON INSERT TO rtest_emp DO INSERT INTO rtest_emplog (ename, who, action, newsal, oldsal) VALUES (new.ename, "current_user"(), 'hired'::bpchar, new.salary, '$0.00'::money);
+ rtest_emp | rtest_emp_upd | CREATE RULE rtest_emp_upd AS ON UPDATE TO rtest_emp WHERE (new.salary <> old.salary) DO INSERT INTO rtest_emplog (ename, who, action, newsal, oldsal) VALUES (new.ename, "current_user"(), 'honored'::bpchar, new.salary, old.salary);
rtest_nothn1 | rtest_nothn_r1 | CREATE RULE rtest_nothn_r1 AS ON INSERT TO rtest_nothn1 WHERE ((new.a >= 10) AND (new.a < 20)) DO INSTEAD NOTHING;
rtest_nothn1 | rtest_nothn_r2 | CREATE RULE rtest_nothn_r2 AS ON INSERT TO rtest_nothn1 WHERE ((new.a >= 30) AND (new.a < 40)) DO INSTEAD NOTHING;
rtest_nothn2 | rtest_nothn_r3 | CREATE RULE rtest_nothn_r3 AS ON INSERT TO rtest_nothn2 WHERE (new.a >= 100) DO INSTEAD INSERT INTO rtest_nothn3 (a, b) VALUES (new.a, new.b);
@@ -1360,7 +1360,7 @@ SELECT tablename, rulename, definition FROM pg_rules
shoelace | shoelace_del | CREATE RULE shoelace_del AS ON DELETE TO shoelace DO INSTEAD DELETE FROM shoelace_data WHERE (shoelace_data.sl_name = old.sl_name);
shoelace | shoelace_ins | CREATE RULE shoelace_ins AS ON INSERT TO shoelace DO INSTEAD INSERT INTO shoelace_data (sl_name, sl_avail, sl_color, sl_len, sl_unit) VALUES (new.sl_name, new.sl_avail, new.sl_color, new.sl_len, new.sl_unit);
shoelace | shoelace_upd | CREATE RULE shoelace_upd AS ON UPDATE TO shoelace DO INSTEAD UPDATE shoelace_data SET sl_name = new.sl_name, sl_avail = new.sl_avail, sl_color = new.sl_color, sl_len = new.sl_len, sl_unit = new.sl_unit WHERE (shoelace_data.sl_name = old.sl_name);
- shoelace_data | log_shoelace | CREATE RULE log_shoelace AS ON UPDATE TO shoelace_data WHERE (new.sl_avail <> old.sl_avail) DO INSERT INTO shoelace_log (sl_name, sl_avail, log_who, log_when) VALUES (new.sl_name, new.sl_avail, 'Al Bundy'::"name", 'Thu Jan 01 00:00:00 1970'::timestamp without time zone);
+ shoelace_data | log_shoelace | CREATE RULE log_shoelace AS ON UPDATE TO shoelace_data WHERE (new.sl_avail <> old.sl_avail) DO INSERT INTO shoelace_log (sl_name, sl_avail, log_who, log_when) VALUES (new.sl_name, new.sl_avail, 'Al Bundy'::name, 'Thu Jan 01 00:00:00 1970'::timestamp without time zone);
shoelace_ok | shoelace_ok_ins | CREATE RULE shoelace_ok_ins AS ON INSERT TO shoelace_ok DO INSTEAD UPDATE shoelace SET sl_avail = (shoelace.sl_avail + new.ok_quant) WHERE (shoelace.sl_name = new.ok_name);
(29 rows)
diff --git a/src/test/regress/expected/xml.out b/src/test/regress/expected/xml.out
index cec9ea294420bb1506aedd4e287096246dd47959..8ffde1dc6af7c9b912a659b1064b300f51551866 100644
--- a/src/test/regress/expected/xml.out
+++ b/src/test/regress/expected/xml.out
@@ -53,7 +53,7 @@ SELECT xmlconcat('hello', 'you');
(1 row)
SELECT xmlconcat(1, 2);
-ERROR: argument of XMLCONCAT must be type "xml", not type integer
+ERROR: argument of XMLCONCAT must be type xml, not type integer
SELECT xmlconcat('bad', '<syntax');
ERROR: invalid XML content
DETAIL: Entity: line 1: parser error : Couldn't find end of Start Tag syntax line 1
@@ -388,17 +388,17 @@ CREATE VIEW xmlview8 AS SELECT xmlserialize(content 'good' as char(10));
CREATE VIEW xmlview9 AS SELECT xmlserialize(content 'good' as text);
SELECT table_name, view_definition FROM information_schema.views
WHERE table_name LIKE 'xmlview%' ORDER BY 1;
- table_name | view_definition
-------------+--------------------------------------------------------------------------------------------------------------------------------
+ table_name | view_definition
+------------+----------------------------------------------------------------------------------------------------------------------------
xmlview1 | SELECT xmlcomment('test'::text) AS xmlcomment;
- xmlview2 | SELECT XMLCONCAT('hello'::"xml", 'you'::"xml") AS "xmlconcat";
+ xmlview2 | SELECT XMLCONCAT('hello'::xml, 'you'::xml) AS "xmlconcat";
xmlview3 | SELECT XMLELEMENT(NAME element, XMLATTRIBUTES(1 AS ":one:", 'deuce' AS two), 'content&') AS "xmlelement";
- xmlview4 | SELECT XMLELEMENT(NAME employee, XMLFOREST(emp."name" AS "name", emp.age AS age, emp.salary AS pay)) AS "xmlelement" FROM emp;
+ xmlview4 | SELECT XMLELEMENT(NAME employee, XMLFOREST(emp.name AS name, emp.age AS age, emp.salary AS pay)) AS "xmlelement" FROM emp;
xmlview5 | SELECT XMLPARSE(CONTENT '<abc>x</abc>'::text STRIP WHITESPACE) AS "xmlparse";
xmlview6 | SELECT XMLPI(NAME foo, 'bar'::text) AS "xmlpi";
- xmlview7 | SELECT XMLROOT('<foo/>'::"xml", VERSION NO VALUE, STANDALONE YES) AS "xmlroot";
- xmlview8 | SELECT (XMLSERIALIZE(CONTENT 'good'::"xml" AS character(10)))::character(10) AS "xmlserialize";
- xmlview9 | SELECT XMLSERIALIZE(CONTENT 'good'::"xml" AS text) AS "xmlserialize";
+ xmlview7 | SELECT XMLROOT('<foo/>'::xml, VERSION NO VALUE, STANDALONE YES) AS "xmlroot";
+ xmlview8 | SELECT (XMLSERIALIZE(CONTENT 'good'::xml AS character(10)))::character(10) AS "xmlserialize";
+ xmlview9 | SELECT XMLSERIALIZE(CONTENT 'good'::xml AS text) AS "xmlserialize";
(9 rows)
-- Text XPath expressions evaluation
diff --git a/src/test/regress/expected/xml_1.out b/src/test/regress/expected/xml_1.out
index 2bf910577057dc26ff3aaf4556ffeec5694ede9f..68cd823bcbd30852ebe0dc3dba95ff53dfe18403 100644
--- a/src/test/regress/expected/xml_1.out
+++ b/src/test/regress/expected/xml_1.out
@@ -50,7 +50,7 @@ ERROR: unsupported XML feature
DETAIL: This functionality requires libxml support.
HINT: You need to re-compile PostgreSQL using --with-libxml.
SELECT xmlconcat(1, 2);
-ERROR: argument of XMLCONCAT must be type "xml", not type integer
+ERROR: argument of XMLCONCAT must be type xml, not type integer
SELECT xmlconcat('bad', '<syntax');
ERROR: unsupported XML feature
DETAIL: This functionality requires libxml support.
diff --git a/src/test/regress/output/create_function_1.source b/src/test/regress/output/create_function_1.source
index e7fd46130f0d96e86d2da8e8985a21438e53c17e..1b309cf11a7815b5bb744c5fe8b1102e7413feb0 100644
--- a/src/test/regress/output/create_function_1.source
+++ b/src/test/regress/output/create_function_1.source
@@ -51,7 +51,7 @@ CREATE FUNCTION set_ttdummy (int4)
CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
AS 'SELECT ''not an integer'';';
ERROR: return type mismatch in function declared to return integer
-DETAIL: Actual return type is "unknown".
+DETAIL: Actual return type is unknown.
CONTEXT: SQL function "test1"
CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
AS 'not even SQL';