From a6e65c54c9b620f90b3c810bb74953df15167e6e Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sat, 13 Jul 2024 12:50:43 -0400 Subject: [PATCH v1 5/5] Run pgindent on tab-complete.in.c. For now, this is mostly to keep the cfbot off my back. But I'd envision committing this as a separate step that we can add to .git-blame-ignore-revs, since it reindents a whole lotta existing code. --- src/bin/psql/tab-complete.in.c | 3779 +++++++++++++++--------------- src/tools/pgindent/typedefs.list | 1 + 2 files changed, 1942 insertions(+), 1838 deletions(-) diff --git a/src/bin/psql/tab-complete.in.c b/src/bin/psql/tab-complete.in.c index a3bd6b7970..ec0bd8ea67 100644 --- a/src/bin/psql/tab-complete.in.c +++ b/src/bin/psql/tab-complete.in.c @@ -2073,1057 +2073,1093 @@ match_previous_words(int pattern_id, switch (pattern_id) { /* CREATE */ - /* complete with something you can create */ + /* complete with something you can create */ case TailMatches("CREATE"): - /* only some object types can be created as part of CREATE SCHEMA */ - if (HeadMatches("CREATE", "SCHEMA")) - COMPLETE_WITH("TABLE", "VIEW", "INDEX", "SEQUENCE", "TRIGGER", - /* for INDEX and TABLE/SEQUENCE, respectively */ - "UNIQUE", "UNLOGGED"); - else - matches = rl_completion_matches(text, create_command_generator); + /* only some object types can be created as part of CREATE SCHEMA */ + if (HeadMatches("CREATE", "SCHEMA")) + COMPLETE_WITH("TABLE", "VIEW", "INDEX", "SEQUENCE", "TRIGGER", + /* for INDEX and TABLE/SEQUENCE, respectively */ + "UNIQUE", "UNLOGGED"); + else + matches = rl_completion_matches(text, create_command_generator); break; - /* complete with something you can create or replace */ + /* complete with something you can create or replace */ case TailMatches("CREATE", "OR", "REPLACE"): - COMPLETE_WITH("FUNCTION", "PROCEDURE", "LANGUAGE", "RULE", "VIEW", - "AGGREGATE", "TRANSFORM", "TRIGGER"); + COMPLETE_WITH("FUNCTION", "PROCEDURE", "LANGUAGE", "RULE", "VIEW", + "AGGREGATE", "TRANSFORM", "TRIGGER"); break; /* DROP, but not DROP embedded in other commands */ - /* complete with something you can drop */ + /* complete with something you can drop */ case Matches("DROP"): - matches = rl_completion_matches(text, drop_command_generator); + matches = rl_completion_matches(text, drop_command_generator); break; /* ALTER */ - /* ALTER TABLE */ + /* ALTER TABLE */ case Matches("ALTER", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, - "ALL IN TABLESPACE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, + "ALL IN TABLESPACE"); break; - /* ALTER something */ + /* ALTER something */ case Matches("ALTER"): - matches = rl_completion_matches(text, alter_command_generator); + matches = rl_completion_matches(text, alter_command_generator); break; - /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx */ + /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx */ case TailMatches("ALL", "IN", "TABLESPACE", MatchAny): - COMPLETE_WITH("SET TABLESPACE", "OWNED BY"); + COMPLETE_WITH("SET TABLESPACE", "OWNED BY"); break; - /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx OWNED BY */ + + /* + * ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx OWNED + * BY + */ case TailMatches("ALL", "IN", "TABLESPACE", MatchAny, "OWNED", "BY"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; - /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx OWNED BY xxx */ + + /* + * ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx OWNED + * BY xxx + */ case TailMatches("ALL", "IN", "TABLESPACE", MatchAny, "OWNED", "BY", MatchAny): - COMPLETE_WITH("SET TABLESPACE"); + COMPLETE_WITH("SET TABLESPACE"); break; - /* ALTER AGGREGATE,FUNCTION,PROCEDURE,ROUTINE */ + /* ALTER AGGREGATE,FUNCTION,PROCEDURE,ROUTINE */ case Matches("ALTER", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER AGGREGATE (...) */ + /* ALTER AGGREGATE (...) */ case Matches("ALTER", "AGGREGATE", MatchAny, MatchAny): - if (ends_with(prev_wd, ')')) - COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA"); - else - COMPLETE_WITH_FUNCTION_ARG(prev2_wd); + if (ends_with(prev_wd, ')')) + COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA"); + else + COMPLETE_WITH_FUNCTION_ARG(prev2_wd); break; - /* ALTER FUNCTION (...) */ + /* ALTER FUNCTION (...) */ case Matches("ALTER", "FUNCTION", MatchAny, MatchAny): - if (ends_with(prev_wd, ')')) - COMPLETE_WITH(Alter_function_options); - else - COMPLETE_WITH_FUNCTION_ARG(prev2_wd); + if (ends_with(prev_wd, ')')) + COMPLETE_WITH(Alter_function_options); + else + COMPLETE_WITH_FUNCTION_ARG(prev2_wd); break; - /* ALTER PROCEDURE (...) */ + /* ALTER PROCEDURE (...) */ case Matches("ALTER", "PROCEDURE", MatchAny, MatchAny): - if (ends_with(prev_wd, ')')) - COMPLETE_WITH(Alter_procedure_options); - else - COMPLETE_WITH_FUNCTION_ARG(prev2_wd); + if (ends_with(prev_wd, ')')) + COMPLETE_WITH(Alter_procedure_options); + else + COMPLETE_WITH_FUNCTION_ARG(prev2_wd); break; - /* ALTER ROUTINE (...) */ + /* ALTER ROUTINE (...) */ case Matches("ALTER", "ROUTINE", MatchAny, MatchAny): - if (ends_with(prev_wd, ')')) - COMPLETE_WITH(Alter_routine_options); - else - COMPLETE_WITH_FUNCTION_ARG(prev2_wd); + if (ends_with(prev_wd, ')')) + COMPLETE_WITH(Alter_routine_options); + else + COMPLETE_WITH_FUNCTION_ARG(prev2_wd); break; - /* ALTER FUNCTION|ROUTINE (...) PARALLEL */ + /* ALTER FUNCTION|ROUTINE (...) PARALLEL */ case Matches("ALTER", "FUNCTION|ROUTINE", MatchAny, MatchAny, "PARALLEL"): - COMPLETE_WITH("RESTRICTED", "SAFE", "UNSAFE"); + COMPLETE_WITH("RESTRICTED", "SAFE", "UNSAFE"); break; - /* ALTER FUNCTION|PROCEDURE|ROUTINE (...) [EXTERNAL] SECURITY */ + + /* + * ALTER FUNCTION|PROCEDURE|ROUTINE (...) [EXTERNAL] + * SECURITY + */ case Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "SECURITY"): case Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "EXTERNAL", "SECURITY"): - COMPLETE_WITH("DEFINER", "INVOKER"); + COMPLETE_WITH("DEFINER", "INVOKER"); break; - /* ALTER FUNCTION|PROCEDURE|ROUTINE (...) RESET */ + /* ALTER FUNCTION|PROCEDURE|ROUTINE (...) RESET */ case Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "RESET"): - COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars, - "ALL"); + COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars, + "ALL"); break; - /* ALTER FUNCTION|PROCEDURE|ROUTINE (...) SET */ + /* ALTER FUNCTION|PROCEDURE|ROUTINE (...) SET */ case Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "SET"): - COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars, - "SCHEMA"); + COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars, + "SCHEMA"); break; - /* ALTER PUBLICATION */ + /* ALTER PUBLICATION */ case Matches("ALTER", "PUBLICATION", MatchAny): - COMPLETE_WITH("ADD", "DROP", "OWNER TO", "RENAME TO", "SET"); + COMPLETE_WITH("ADD", "DROP", "OWNER TO", "RENAME TO", "SET"); break; - /* ALTER PUBLICATION ADD */ + /* ALTER PUBLICATION ADD */ case Matches("ALTER", "PUBLICATION", MatchAny, "ADD"): - COMPLETE_WITH("TABLES IN SCHEMA", "TABLE"); + COMPLETE_WITH("TABLES IN SCHEMA", "TABLE"); break; case Matches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; case HeadMatches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE"): - if (ends_with(prev_wd, ',')) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + if (ends_with(prev_wd, ',')) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* - * "ALTER PUBLICATION SET TABLE WHERE (" - complete with - * table attributes - * - * "ALTER PUBLICATION ADD TABLE WHERE (" - complete with - * table attributes - */ + /* + * "ALTER PUBLICATION SET TABLE WHERE (" - complete + * with table attributes + * + * "ALTER PUBLICATION ADD TABLE WHERE (" - complete + * with table attributes + */ case Matches("ALTER", "PUBLICATION", MatchAny, MatchAnyN, "WHERE"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; case Matches("ALTER", "PUBLICATION", MatchAny, MatchAnyN, "WHERE", "("): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; case HeadMatches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE"): - if (!TailMatches("WHERE", "(*)")) - COMPLETE_WITH(",", "WHERE ("); + if (!TailMatches("WHERE", "(*)")) + COMPLETE_WITH(",", "WHERE ("); break; case HeadMatches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE"): - COMPLETE_WITH(","); + COMPLETE_WITH(","); break; - /* ALTER PUBLICATION DROP */ + /* ALTER PUBLICATION DROP */ case Matches("ALTER", "PUBLICATION", MatchAny, "DROP"): - COMPLETE_WITH("TABLES IN SCHEMA", "TABLE"); + COMPLETE_WITH("TABLES IN SCHEMA", "TABLE"); break; - /* ALTER PUBLICATION SET */ + /* ALTER PUBLICATION SET */ case Matches("ALTER", "PUBLICATION", MatchAny, "SET"): - COMPLETE_WITH("(", "TABLES IN SCHEMA", "TABLE"); + COMPLETE_WITH("(", "TABLES IN SCHEMA", "TABLE"); break; case Matches("ALTER", "PUBLICATION", MatchAny, "ADD|DROP|SET", "TABLES", "IN", "SCHEMA"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas - " AND nspname NOT LIKE E'pg\\\\_%%'", - "CURRENT_SCHEMA"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas + " AND nspname NOT LIKE E'pg\\\\_%%'", + "CURRENT_SCHEMA"); break; - /* ALTER PUBLICATION SET ( */ + /* ALTER PUBLICATION SET ( */ case Matches("ALTER", "PUBLICATION", MatchAny, MatchAnyN, "SET", "("): - COMPLETE_WITH("publish", "publish_via_partition_root"); + COMPLETE_WITH("publish", "publish_via_partition_root"); break; - /* ALTER SUBSCRIPTION */ + /* ALTER SUBSCRIPTION */ case Matches("ALTER", "SUBSCRIPTION", MatchAny): - COMPLETE_WITH("CONNECTION", "ENABLE", "DISABLE", "OWNER TO", - "RENAME TO", "REFRESH PUBLICATION", "SET", "SKIP (", - "ADD PUBLICATION", "DROP PUBLICATION"); + COMPLETE_WITH("CONNECTION", "ENABLE", "DISABLE", "OWNER TO", + "RENAME TO", "REFRESH PUBLICATION", "SET", "SKIP (", + "ADD PUBLICATION", "DROP PUBLICATION"); break; - /* ALTER SUBSCRIPTION REFRESH PUBLICATION */ + /* ALTER SUBSCRIPTION REFRESH PUBLICATION */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "REFRESH", "PUBLICATION"): - COMPLETE_WITH("WITH ("); + COMPLETE_WITH("WITH ("); break; - /* ALTER SUBSCRIPTION REFRESH PUBLICATION WITH ( */ + /* ALTER SUBSCRIPTION REFRESH PUBLICATION WITH ( */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "REFRESH", "PUBLICATION", "WITH", "("): - COMPLETE_WITH("copy_data"); + COMPLETE_WITH("copy_data"); break; - /* ALTER SUBSCRIPTION SET */ + /* ALTER SUBSCRIPTION SET */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, "SET"): - COMPLETE_WITH("(", "PUBLICATION"); + COMPLETE_WITH("(", "PUBLICATION"); break; - /* ALTER SUBSCRIPTION SET ( */ + /* ALTER SUBSCRIPTION SET ( */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "SET", "("): - COMPLETE_WITH("binary", "disable_on_error", "failover", "origin", - "password_required", "run_as_owner", "slot_name", - "streaming", "synchronous_commit"); + COMPLETE_WITH("binary", "disable_on_error", "failover", "origin", + "password_required", "run_as_owner", "slot_name", + "streaming", "synchronous_commit"); break; - /* ALTER SUBSCRIPTION SKIP ( */ + /* ALTER SUBSCRIPTION SKIP ( */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "SKIP", "("): - COMPLETE_WITH("lsn"); + COMPLETE_WITH("lsn"); break; - /* ALTER SUBSCRIPTION SET PUBLICATION */ + /* ALTER SUBSCRIPTION SET PUBLICATION */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "SET", "PUBLICATION"): - /* complete with nothing here as this refers to remote publications */ + + /* + * complete with nothing here as this refers to remote + * publications + */ break; - /* ALTER SUBSCRIPTION ADD|DROP|SET PUBLICATION */ + /* ALTER SUBSCRIPTION ADD|DROP|SET PUBLICATION */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "ADD|DROP|SET", "PUBLICATION", MatchAny): - COMPLETE_WITH("WITH ("); + COMPLETE_WITH("WITH ("); break; - /* ALTER SUBSCRIPTION ADD|DROP|SET PUBLICATION WITH ( */ + + /* + * ALTER SUBSCRIPTION ADD|DROP|SET PUBLICATION WITH + * ( + */ case Matches("ALTER", "SUBSCRIPTION", MatchAny, MatchAnyN, "ADD|DROP|SET", "PUBLICATION", MatchAny, "WITH", "("): - COMPLETE_WITH("copy_data", "refresh"); + COMPLETE_WITH("copy_data", "refresh"); break; - /* ALTER SCHEMA */ + /* ALTER SCHEMA */ case Matches("ALTER", "SCHEMA", MatchAny): - COMPLETE_WITH("OWNER TO", "RENAME TO"); + COMPLETE_WITH("OWNER TO", "RENAME TO"); break; - /* ALTER COLLATION */ + /* ALTER COLLATION */ case Matches("ALTER", "COLLATION", MatchAny): - COMPLETE_WITH("OWNER TO", "REFRESH VERSION", "RENAME TO", "SET SCHEMA"); + COMPLETE_WITH("OWNER TO", "REFRESH VERSION", "RENAME TO", "SET SCHEMA"); break; - /* ALTER CONVERSION */ + /* ALTER CONVERSION */ case Matches("ALTER", "CONVERSION", MatchAny): - COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA"); + COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA"); break; - /* ALTER DATABASE */ + /* ALTER DATABASE */ case Matches("ALTER", "DATABASE", MatchAny): - COMPLETE_WITH("RESET", "SET", "OWNER TO", "REFRESH COLLATION VERSION", "RENAME TO", - "IS_TEMPLATE", "ALLOW_CONNECTIONS", - "CONNECTION LIMIT"); + COMPLETE_WITH("RESET", "SET", "OWNER TO", "REFRESH COLLATION VERSION", "RENAME TO", + "IS_TEMPLATE", "ALLOW_CONNECTIONS", + "CONNECTION LIMIT"); break; - /* ALTER DATABASE SET TABLESPACE */ + /* ALTER DATABASE SET TABLESPACE */ case Matches("ALTER", "DATABASE", MatchAny, "SET", "TABLESPACE"): - COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); + COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); break; - /* ALTER EVENT TRIGGER */ + /* ALTER EVENT TRIGGER */ case Matches("ALTER", "EVENT", "TRIGGER"): - COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); + COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); break; - /* ALTER EVENT TRIGGER */ + /* ALTER EVENT TRIGGER */ case Matches("ALTER", "EVENT", "TRIGGER", MatchAny): - COMPLETE_WITH("DISABLE", "ENABLE", "OWNER TO", "RENAME TO"); + COMPLETE_WITH("DISABLE", "ENABLE", "OWNER TO", "RENAME TO"); break; - /* ALTER EVENT TRIGGER ENABLE */ + /* ALTER EVENT TRIGGER ENABLE */ case Matches("ALTER", "EVENT", "TRIGGER", MatchAny, "ENABLE"): - COMPLETE_WITH("REPLICA", "ALWAYS"); + COMPLETE_WITH("REPLICA", "ALWAYS"); break; - /* ALTER EXTENSION */ + /* ALTER EXTENSION */ case Matches("ALTER", "EXTENSION", MatchAny): - COMPLETE_WITH("ADD", "DROP", "UPDATE", "SET SCHEMA"); + COMPLETE_WITH("ADD", "DROP", "UPDATE", "SET SCHEMA"); break; - /* ALTER EXTENSION ADD|DROP */ + /* ALTER EXTENSION ADD|DROP */ case Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP"): - COMPLETE_WITH("ACCESS METHOD", "AGGREGATE", "CAST", "COLLATION", - "CONVERSION", "DOMAIN", "EVENT TRIGGER", "FOREIGN", - "FUNCTION", "MATERIALIZED VIEW", "OPERATOR", - "LANGUAGE", "PROCEDURE", "ROUTINE", "SCHEMA", - "SEQUENCE", "SERVER", "TABLE", "TEXT SEARCH", - "TRANSFORM FOR", "TYPE", "VIEW"); + COMPLETE_WITH("ACCESS METHOD", "AGGREGATE", "CAST", "COLLATION", + "CONVERSION", "DOMAIN", "EVENT TRIGGER", "FOREIGN", + "FUNCTION", "MATERIALIZED VIEW", "OPERATOR", + "LANGUAGE", "PROCEDURE", "ROUTINE", "SCHEMA", + "SEQUENCE", "SERVER", "TABLE", "TEXT SEARCH", + "TRANSFORM FOR", "TYPE", "VIEW"); break; - /* ALTER EXTENSION ADD|DROP FOREIGN */ + /* ALTER EXTENSION ADD|DROP FOREIGN */ case Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP", "FOREIGN"): - COMPLETE_WITH("DATA WRAPPER", "TABLE"); + COMPLETE_WITH("DATA WRAPPER", "TABLE"); break; - /* ALTER EXTENSION ADD|DROP OPERATOR */ + /* ALTER EXTENSION ADD|DROP OPERATOR */ case Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP", "OPERATOR"): - COMPLETE_WITH("CLASS", "FAMILY"); + COMPLETE_WITH("CLASS", "FAMILY"); break; - /* ALTER EXTENSION ADD|DROP TEXT SEARCH */ + /* ALTER EXTENSION ADD|DROP TEXT SEARCH */ case Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP", "TEXT", "SEARCH"): - COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); + COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); break; - /* ALTER EXTENSION UPDATE */ + /* ALTER EXTENSION UPDATE */ case Matches("ALTER", "EXTENSION", MatchAny, "UPDATE"): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER EXTENSION UPDATE TO */ + /* ALTER EXTENSION UPDATE TO */ case Matches("ALTER", "EXTENSION", MatchAny, "UPDATE", "TO"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions); + set_completion_reference(prev3_wd); + COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions); break; - /* ALTER FOREIGN */ + /* ALTER FOREIGN */ case Matches("ALTER", "FOREIGN"): - COMPLETE_WITH("DATA WRAPPER", "TABLE"); + COMPLETE_WITH("DATA WRAPPER", "TABLE"); break; - /* ALTER FOREIGN DATA WRAPPER */ + /* ALTER FOREIGN DATA WRAPPER */ case Matches("ALTER", "FOREIGN", "DATA", "WRAPPER", MatchAny): - COMPLETE_WITH("HANDLER", "VALIDATOR", "NO", - "OPTIONS", "OWNER TO", "RENAME TO"); + COMPLETE_WITH("HANDLER", "VALIDATOR", "NO", + "OPTIONS", "OWNER TO", "RENAME TO"); break; case Matches("ALTER", "FOREIGN", "DATA", "WRAPPER", MatchAny, "NO"): - COMPLETE_WITH("HANDLER", "VALIDATOR"); + COMPLETE_WITH("HANDLER", "VALIDATOR"); break; - /* ALTER FOREIGN TABLE */ + /* ALTER FOREIGN TABLE */ case Matches("ALTER", "FOREIGN", "TABLE", MatchAny): - COMPLETE_WITH("ADD", "ALTER", "DISABLE TRIGGER", "DROP", "ENABLE", - "INHERIT", "NO INHERIT", "OPTIONS", "OWNER TO", - "RENAME", "SET", "VALIDATE CONSTRAINT"); + COMPLETE_WITH("ADD", "ALTER", "DISABLE TRIGGER", "DROP", "ENABLE", + "INHERIT", "NO INHERIT", "OPTIONS", "OWNER TO", + "RENAME", "SET", "VALIDATE CONSTRAINT"); break; - /* ALTER INDEX */ + /* ALTER INDEX */ case Matches("ALTER", "INDEX"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, - "ALL IN TABLESPACE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, + "ALL IN TABLESPACE"); break; - /* ALTER INDEX */ + /* ALTER INDEX */ case Matches("ALTER", "INDEX", MatchAny): - COMPLETE_WITH("ALTER COLUMN", "OWNER TO", "RENAME TO", "SET", - "RESET", "ATTACH PARTITION", - "DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION"); + COMPLETE_WITH("ALTER COLUMN", "OWNER TO", "RENAME TO", "SET", + "RESET", "ATTACH PARTITION", + "DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION"); break; case Matches("ALTER", "INDEX", MatchAny, "ATTACH"): - COMPLETE_WITH("PARTITION"); + COMPLETE_WITH("PARTITION"); break; case Matches("ALTER", "INDEX", MatchAny, "ATTACH", "PARTITION"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); break; - /* ALTER INDEX ALTER */ + /* ALTER INDEX ALTER */ case Matches("ALTER", "INDEX", MatchAny, "ALTER"): - COMPLETE_WITH("COLUMN"); + COMPLETE_WITH("COLUMN"); break; - /* ALTER INDEX ALTER COLUMN */ + /* ALTER INDEX ALTER COLUMN */ case Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY_VERBATIM(Query_for_list_of_attribute_numbers); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY_VERBATIM(Query_for_list_of_attribute_numbers); break; - /* ALTER INDEX ALTER COLUMN */ + /* ALTER INDEX ALTER COLUMN */ case Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN", MatchAny): - COMPLETE_WITH("SET STATISTICS"); + COMPLETE_WITH("SET STATISTICS"); break; - /* ALTER INDEX ALTER COLUMN SET */ + /* ALTER INDEX ALTER COLUMN SET */ case Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN", MatchAny, "SET"): - COMPLETE_WITH("STATISTICS"); + COMPLETE_WITH("STATISTICS"); break; - /* ALTER INDEX ALTER COLUMN SET STATISTICS */ + /* ALTER INDEX ALTER COLUMN SET STATISTICS */ case Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "STATISTICS"): - /* Enforce no completion here, as an integer has to be specified */ + /* Enforce no completion here, as an integer has to be specified */ break; - /* ALTER INDEX SET */ + /* ALTER INDEX SET */ case Matches("ALTER", "INDEX", MatchAny, "SET"): - COMPLETE_WITH("(", "TABLESPACE"); + COMPLETE_WITH("(", "TABLESPACE"); break; - /* ALTER INDEX RESET */ + /* ALTER INDEX RESET */ case Matches("ALTER", "INDEX", MatchAny, "RESET"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER INDEX SET|RESET ( */ + /* ALTER INDEX SET|RESET ( */ case Matches("ALTER", "INDEX", MatchAny, "RESET", "("): - COMPLETE_WITH("fillfactor", - "deduplicate_items", /* BTREE */ - "fastupdate", "gin_pending_list_limit", /* GIN */ - "buffering", /* GiST */ - "pages_per_range", "autosummarize" /* BRIN */ - ); + COMPLETE_WITH("fillfactor", + "deduplicate_items", /* BTREE */ + "fastupdate", "gin_pending_list_limit", /* GIN */ + "buffering", /* GiST */ + "pages_per_range", "autosummarize" /* BRIN */ + ); break; case Matches("ALTER", "INDEX", MatchAny, "SET", "("): - COMPLETE_WITH("fillfactor =", - "deduplicate_items =", /* BTREE */ - "fastupdate =", "gin_pending_list_limit =", /* GIN */ - "buffering =", /* GiST */ - "pages_per_range =", "autosummarize =" /* BRIN */ - ); + COMPLETE_WITH("fillfactor =", + "deduplicate_items =", /* BTREE */ + "fastupdate =", "gin_pending_list_limit =", /* GIN */ + "buffering =", /* GiST */ + "pages_per_range =", "autosummarize =" /* BRIN */ + ); break; case Matches("ALTER", "INDEX", MatchAny, "NO", "DEPENDS"): - COMPLETE_WITH("ON EXTENSION"); + COMPLETE_WITH("ON EXTENSION"); break; case Matches("ALTER", "INDEX", MatchAny, "DEPENDS"): - COMPLETE_WITH("ON EXTENSION"); + COMPLETE_WITH("ON EXTENSION"); break; - /* ALTER LANGUAGE */ + /* ALTER LANGUAGE */ case Matches("ALTER", "LANGUAGE", MatchAny): - COMPLETE_WITH("OWNER TO", "RENAME TO"); + COMPLETE_WITH("OWNER TO", "RENAME TO"); break; - /* ALTER LARGE OBJECT */ + /* ALTER LARGE OBJECT */ case Matches("ALTER", "LARGE", "OBJECT", MatchAny): - COMPLETE_WITH("OWNER TO"); + COMPLETE_WITH("OWNER TO"); break; - /* ALTER MATERIALIZED VIEW */ + /* ALTER MATERIALIZED VIEW */ case Matches("ALTER", "MATERIALIZED", "VIEW"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_matviews, - "ALL IN TABLESPACE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_matviews, + "ALL IN TABLESPACE"); break; - /* ALTER USER,ROLE */ + /* ALTER USER,ROLE */ case Matches("ALTER", "USER|ROLE", MatchAny): - if (!TailMatches("USER", "MAPPING")) - COMPLETE_WITH("BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE", - "ENCRYPTED PASSWORD", "INHERIT", "LOGIN", "NOBYPASSRLS", - "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", - "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", - "RENAME TO", "REPLICATION", "RESET", "SET", "SUPERUSER", - "VALID UNTIL", "WITH"); + if (!TailMatches("USER", "MAPPING")) + COMPLETE_WITH("BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE", + "ENCRYPTED PASSWORD", "INHERIT", "LOGIN", "NOBYPASSRLS", + "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", + "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", + "RENAME TO", "REPLICATION", "RESET", "SET", "SUPERUSER", + "VALID UNTIL", "WITH"); break; - /* ALTER USER,ROLE WITH */ + /* ALTER USER,ROLE WITH */ case Matches("ALTER", "USER|ROLE", MatchAny, "WITH"): - /* Similar to the above, but don't complete "WITH" again. */ - COMPLETE_WITH("BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE", - "ENCRYPTED PASSWORD", "INHERIT", "LOGIN", "NOBYPASSRLS", - "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", - "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", - "RENAME TO", "REPLICATION", "RESET", "SET", "SUPERUSER", - "VALID UNTIL"); + /* Similar to the above, but don't complete "WITH" again. */ + COMPLETE_WITH("BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE", + "ENCRYPTED PASSWORD", "INHERIT", "LOGIN", "NOBYPASSRLS", + "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", + "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", + "RENAME TO", "REPLICATION", "RESET", "SET", "SUPERUSER", + "VALID UNTIL"); break; - /* ALTER DEFAULT PRIVILEGES */ + /* ALTER DEFAULT PRIVILEGES */ case Matches("ALTER", "DEFAULT", "PRIVILEGES"): - COMPLETE_WITH("FOR", "GRANT", "IN SCHEMA", "REVOKE"); + COMPLETE_WITH("FOR", "GRANT", "IN SCHEMA", "REVOKE"); break; - /* ALTER DEFAULT PRIVILEGES FOR */ + /* ALTER DEFAULT PRIVILEGES FOR */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", "FOR"): - COMPLETE_WITH("ROLE"); + COMPLETE_WITH("ROLE"); break; - /* ALTER DEFAULT PRIVILEGES IN */ + /* ALTER DEFAULT PRIVILEGES IN */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN"): - COMPLETE_WITH("SCHEMA"); + COMPLETE_WITH("SCHEMA"); break; - /* ALTER DEFAULT PRIVILEGES FOR ROLE|USER ... */ + /* ALTER DEFAULT PRIVILEGES FOR ROLE|USER ... */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", "FOR", "ROLE|USER", MatchAny): - COMPLETE_WITH("GRANT", "REVOKE", "IN SCHEMA"); + COMPLETE_WITH("GRANT", "REVOKE", "IN SCHEMA"); break; - /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... */ + /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN", "SCHEMA", MatchAny): - COMPLETE_WITH("GRANT", "REVOKE", "FOR ROLE"); + COMPLETE_WITH("GRANT", "REVOKE", "FOR ROLE"); break; - /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... FOR */ + /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... FOR */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN", "SCHEMA", MatchAny, "FOR"): - COMPLETE_WITH("ROLE"); + COMPLETE_WITH("ROLE"); break; - /* ALTER DEFAULT PRIVILEGES FOR ROLE|USER ... IN SCHEMA ... */ - /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... FOR ROLE|USER ... */ + /* ALTER DEFAULT PRIVILEGES FOR ROLE|USER ... IN SCHEMA ... */ + /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... FOR ROLE|USER ... */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", "FOR", "ROLE|USER", MatchAny, "IN", "SCHEMA", MatchAny): case Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN", "SCHEMA", MatchAny, "FOR", "ROLE|USER", MatchAny): - COMPLETE_WITH("GRANT", "REVOKE"); + COMPLETE_WITH("GRANT", "REVOKE"); break; - /* ALTER DOMAIN */ + /* ALTER DOMAIN */ case Matches("ALTER", "DOMAIN", MatchAny): - COMPLETE_WITH("ADD", "DROP", "OWNER TO", "RENAME", "SET", - "VALIDATE CONSTRAINT"); + COMPLETE_WITH("ADD", "DROP", "OWNER TO", "RENAME", "SET", + "VALIDATE CONSTRAINT"); break; - /* ALTER DOMAIN DROP */ + /* ALTER DOMAIN DROP */ case Matches("ALTER", "DOMAIN", MatchAny, "DROP"): - COMPLETE_WITH("CONSTRAINT", "DEFAULT", "NOT NULL"); + COMPLETE_WITH("CONSTRAINT", "DEFAULT", "NOT NULL"); break; - /* ALTER DOMAIN DROP|RENAME|VALIDATE CONSTRAINT */ + /* ALTER DOMAIN DROP|RENAME|VALIDATE CONSTRAINT */ case Matches("ALTER", "DOMAIN", MatchAny, "DROP|RENAME|VALIDATE", "CONSTRAINT"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_type); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_type); break; - /* ALTER DOMAIN RENAME */ + /* ALTER DOMAIN RENAME */ case Matches("ALTER", "DOMAIN", MatchAny, "RENAME"): - COMPLETE_WITH("CONSTRAINT", "TO"); + COMPLETE_WITH("CONSTRAINT", "TO"); break; - /* ALTER DOMAIN RENAME CONSTRAINT */ + /* ALTER DOMAIN RENAME CONSTRAINT */ case Matches("ALTER", "DOMAIN", MatchAny, "RENAME", "CONSTRAINT", MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER DOMAIN SET */ + /* ALTER DOMAIN SET */ case Matches("ALTER", "DOMAIN", MatchAny, "SET"): - COMPLETE_WITH("DEFAULT", "NOT NULL", "SCHEMA"); + COMPLETE_WITH("DEFAULT", "NOT NULL", "SCHEMA"); break; - /* ALTER SEQUENCE */ + /* ALTER SEQUENCE */ case Matches("ALTER", "SEQUENCE", MatchAny): - COMPLETE_WITH("AS", "INCREMENT", "MINVALUE", "MAXVALUE", "RESTART", - "START", "NO", "CACHE", "CYCLE", "SET", "OWNED BY", - "OWNER TO", "RENAME TO"); + COMPLETE_WITH("AS", "INCREMENT", "MINVALUE", "MAXVALUE", "RESTART", + "START", "NO", "CACHE", "CYCLE", "SET", "OWNED BY", + "OWNER TO", "RENAME TO"); break; - /* ALTER SEQUENCE AS */ + /* ALTER SEQUENCE AS */ case TailMatches("ALTER", "SEQUENCE", MatchAny, "AS"): - COMPLETE_WITH_CS("smallint", "integer", "bigint"); + COMPLETE_WITH_CS("smallint", "integer", "bigint"); break; - /* ALTER SEQUENCE NO */ + /* ALTER SEQUENCE NO */ case Matches("ALTER", "SEQUENCE", MatchAny, "NO"): - COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE"); + COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE"); break; - /* ALTER SEQUENCE SET */ + /* ALTER SEQUENCE SET */ case Matches("ALTER", "SEQUENCE", MatchAny, "SET"): - COMPLETE_WITH("SCHEMA", "LOGGED", "UNLOGGED"); + COMPLETE_WITH("SCHEMA", "LOGGED", "UNLOGGED"); break; - /* ALTER SERVER */ + /* ALTER SERVER */ case Matches("ALTER", "SERVER", MatchAny): - COMPLETE_WITH("VERSION", "OPTIONS", "OWNER TO", "RENAME TO"); + COMPLETE_WITH("VERSION", "OPTIONS", "OWNER TO", "RENAME TO"); break; - /* ALTER SERVER VERSION */ + /* ALTER SERVER VERSION */ case Matches("ALTER", "SERVER", MatchAny, "VERSION", MatchAny): - COMPLETE_WITH("OPTIONS"); + COMPLETE_WITH("OPTIONS"); break; - /* ALTER SYSTEM SET, RESET, RESET ALL */ + /* ALTER SYSTEM SET, RESET, RESET ALL */ case Matches("ALTER", "SYSTEM"): - COMPLETE_WITH("SET", "RESET"); + COMPLETE_WITH("SET", "RESET"); break; case Matches("ALTER", "SYSTEM", "SET|RESET"): - COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_alter_system_set_vars, - "ALL"); + COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_alter_system_set_vars, + "ALL"); break; case Matches("ALTER", "SYSTEM", "SET", MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER VIEW */ + /* ALTER VIEW */ case Matches("ALTER", "VIEW", MatchAny): - COMPLETE_WITH("ALTER COLUMN", "OWNER TO", "RENAME", "RESET", "SET"); + COMPLETE_WITH("ALTER COLUMN", "OWNER TO", "RENAME", "RESET", "SET"); break; - /* ALTER VIEW xxx RENAME */ + /* ALTER VIEW xxx RENAME */ case Matches("ALTER", "VIEW", MatchAny, "RENAME"): - COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "TO"); + COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "TO"); break; case Matches("ALTER", "VIEW", MatchAny, "ALTER|RENAME", "COLUMN"): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; - /* ALTER VIEW xxx ALTER [ COLUMN ] yyy */ + /* ALTER VIEW xxx ALTER [ COLUMN ] yyy */ case Matches("ALTER", "VIEW", MatchAny, "ALTER", MatchAny): case Matches("ALTER", "VIEW", MatchAny, "ALTER", "COLUMN", MatchAny): - COMPLETE_WITH("SET DEFAULT", "DROP DEFAULT"); + COMPLETE_WITH("SET DEFAULT", "DROP DEFAULT"); break; - /* ALTER VIEW xxx RENAME yyy */ + /* ALTER VIEW xxx RENAME yyy */ case Matches("ALTER", "VIEW", MatchAny, "RENAME", MatchAnyExcept("TO")): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER VIEW xxx RENAME COLUMN yyy */ + /* ALTER VIEW xxx RENAME COLUMN yyy */ case Matches("ALTER", "VIEW", MatchAny, "RENAME", "COLUMN", MatchAnyExcept("TO")): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER VIEW xxx RESET ( */ + /* ALTER VIEW xxx RESET ( */ case Matches("ALTER", "VIEW", MatchAny, "RESET"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* Complete ALTER VIEW xxx SET with "(" or "SCHEMA" */ + /* Complete ALTER VIEW xxx SET with "(" or "SCHEMA" */ case Matches("ALTER", "VIEW", MatchAny, "SET"): - COMPLETE_WITH("(", "SCHEMA"); + COMPLETE_WITH("(", "SCHEMA"); break; - /* ALTER VIEW xxx SET|RESET ( yyy [= zzz] ) */ + /* ALTER VIEW xxx SET|RESET ( yyy [= zzz] ) */ case Matches("ALTER", "VIEW", MatchAny, "SET|RESET", "("): - COMPLETE_WITH_LIST(view_optional_parameters); + COMPLETE_WITH_LIST(view_optional_parameters); break; case Matches("ALTER", "VIEW", MatchAny, "SET", "(", MatchAny): - COMPLETE_WITH("="); + COMPLETE_WITH("="); break; case Matches("ALTER", "VIEW", MatchAny, "SET", "(", "check_option", "="): - COMPLETE_WITH("local", "cascaded"); + COMPLETE_WITH("local", "cascaded"); break; case Matches("ALTER", "VIEW", MatchAny, "SET", "(", "security_barrier|security_invoker", "="): - COMPLETE_WITH("true", "false"); + COMPLETE_WITH("true", "false"); break; - /* ALTER MATERIALIZED VIEW */ + /* ALTER MATERIALIZED VIEW */ case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny): - COMPLETE_WITH("ALTER COLUMN", "CLUSTER ON", "DEPENDS ON EXTENSION", - "NO DEPENDS ON EXTENSION", "OWNER TO", "RENAME", - "RESET (", "SET"); + COMPLETE_WITH("ALTER COLUMN", "CLUSTER ON", "DEPENDS ON EXTENSION", + "NO DEPENDS ON EXTENSION", "OWNER TO", "RENAME", + "RESET (", "SET"); break; - /* ALTER MATERIALIZED VIEW xxx RENAME */ + /* ALTER MATERIALIZED VIEW xxx RENAME */ case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "RENAME"): - COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "TO"); + COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "TO"); break; case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "ALTER|RENAME", "COLUMN"): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; - /* ALTER MATERIALIZED VIEW xxx RENAME yyy */ + /* ALTER MATERIALIZED VIEW xxx RENAME yyy */ case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "RENAME", MatchAnyExcept("TO")): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER MATERIALIZED VIEW xxx RENAME COLUMN yyy */ + /* ALTER MATERIALIZED VIEW xxx RENAME COLUMN yyy */ case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "RENAME", "COLUMN", MatchAnyExcept("TO")): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER MATERIALIZED VIEW xxx SET */ + /* ALTER MATERIALIZED VIEW xxx SET */ case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "SET"): - COMPLETE_WITH("(", "ACCESS METHOD", "SCHEMA", "TABLESPACE", "WITHOUT CLUSTER"); + COMPLETE_WITH("(", "ACCESS METHOD", "SCHEMA", "TABLESPACE", "WITHOUT CLUSTER"); break; - /* ALTER MATERIALIZED VIEW xxx SET ACCESS METHOD */ + /* ALTER MATERIALIZED VIEW xxx SET ACCESS METHOD */ case Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "SET", "ACCESS", "METHOD"): - COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods); break; - /* ALTER POLICY */ + /* ALTER POLICY */ case Matches("ALTER", "POLICY"): - COMPLETE_WITH_QUERY(Query_for_list_of_policies); + COMPLETE_WITH_QUERY(Query_for_list_of_policies); break; - /* ALTER POLICY ON */ + /* ALTER POLICY ON */ case Matches("ALTER", "POLICY", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* ALTER POLICY ON */ + /* ALTER POLICY ON
*/ case Matches("ALTER", "POLICY", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy); break; - /* ALTER POLICY ON
- show options */ + /* ALTER POLICY ON
- show options */ case Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny): - COMPLETE_WITH("RENAME TO", "TO", "USING (", "WITH CHECK ("); + COMPLETE_WITH("RENAME TO", "TO", "USING (", "WITH CHECK ("); break; - /* ALTER POLICY ON
TO */ + /* ALTER POLICY ON
TO */ case Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny, "TO"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_grant_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_grant_roles); break; - /* ALTER POLICY ON
USING ( */ + /* ALTER POLICY ON
USING ( */ case Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny, "USING"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER POLICY ON
WITH CHECK ( */ + /* ALTER POLICY ON
WITH CHECK ( */ case Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny, "WITH", "CHECK"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER RULE , add ON */ + /* ALTER RULE , add ON */ case Matches("ALTER", "RULE", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* If we have ALTER RULE ON, then add the correct tablename */ + /* If we have ALTER RULE ON, then add the correct tablename */ case Matches("ALTER", "RULE", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule); break; - /* ALTER RULE ON */ + /* ALTER RULE ON */ case Matches("ALTER", "RULE", MatchAny, "ON", MatchAny): - COMPLETE_WITH("RENAME TO"); + COMPLETE_WITH("RENAME TO"); break; - /* ALTER STATISTICS */ + /* ALTER STATISTICS */ case Matches("ALTER", "STATISTICS", MatchAny): - COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA", "SET STATISTICS"); + COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA", "SET STATISTICS"); break; - /* ALTER STATISTICS SET */ + /* ALTER STATISTICS SET */ case Matches("ALTER", "STATISTICS", MatchAny, "SET"): - COMPLETE_WITH("SCHEMA", "STATISTICS"); + COMPLETE_WITH("SCHEMA", "STATISTICS"); break; - /* ALTER TRIGGER , add ON */ + /* ALTER TRIGGER , add ON */ case Matches("ALTER", "TRIGGER", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("ALTER", "TRIGGER", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger); break; - /* ALTER TRIGGER ON */ + /* ALTER TRIGGER ON */ case Matches("ALTER", "TRIGGER", MatchAny, "ON", MatchAny): - COMPLETE_WITH("RENAME TO", "DEPENDS ON EXTENSION", - "NO DEPENDS ON EXTENSION"); + COMPLETE_WITH("RENAME TO", "DEPENDS ON EXTENSION", + "NO DEPENDS ON EXTENSION"); break; - /* - * If we detect ALTER TABLE , suggest sub commands - */ + /* + * If we detect ALTER TABLE , suggest sub commands + */ case Matches("ALTER", "TABLE", MatchAny): - COMPLETE_WITH("ADD", "ALTER", "CLUSTER ON", "DISABLE", "DROP", - "ENABLE", "INHERIT", "NO", "RENAME", "RESET", - "OWNER TO", "SET", "VALIDATE CONSTRAINT", - "REPLICA IDENTITY", "ATTACH PARTITION", - "DETACH PARTITION", "FORCE ROW LEVEL SECURITY", - "SPLIT PARTITION", "MERGE PARTITIONS (", - "OF", "NOT OF"); - break; - /* ALTER TABLE xxx ADD */ + COMPLETE_WITH("ADD", "ALTER", "CLUSTER ON", "DISABLE", "DROP", + "ENABLE", "INHERIT", "NO", "RENAME", "RESET", + "OWNER TO", "SET", "VALIDATE CONSTRAINT", + "REPLICA IDENTITY", "ATTACH PARTITION", + "DETACH PARTITION", "FORCE ROW LEVEL SECURITY", + "SPLIT PARTITION", "MERGE PARTITIONS (", + "OF", "NOT OF"); + break; + /* ALTER TABLE xxx ADD */ case Matches("ALTER", "TABLE", MatchAny, "ADD"): - /* make sure to keep this list and the !Matches() below in sync */ - COMPLETE_WITH("COLUMN", "CONSTRAINT", "CHECK", "UNIQUE", "PRIMARY KEY", - "EXCLUDE", "FOREIGN KEY"); + /* make sure to keep this list and the !Matches() below in sync */ + COMPLETE_WITH("COLUMN", "CONSTRAINT", "CHECK", "UNIQUE", "PRIMARY KEY", + "EXCLUDE", "FOREIGN KEY"); break; - /* ALTER TABLE xxx ADD [COLUMN] yyy */ + /* ALTER TABLE xxx ADD [COLUMN] yyy */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "COLUMN", MatchAny): case Matches("ALTER", "TABLE", MatchAny, "ADD", MatchAnyExcept("COLUMN|CONSTRAINT|CHECK|UNIQUE|PRIMARY|EXCLUDE|FOREIGN")): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; - /* ALTER TABLE xxx ADD CONSTRAINT yyy */ + /* ALTER TABLE xxx ADD CONSTRAINT yyy */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny): - COMPLETE_WITH("CHECK", "UNIQUE", "PRIMARY KEY", "EXCLUDE", "FOREIGN KEY"); + COMPLETE_WITH("CHECK", "UNIQUE", "PRIMARY KEY", "EXCLUDE", "FOREIGN KEY"); break; - /* ALTER TABLE xxx ADD [CONSTRAINT yyy] (PRIMARY KEY|UNIQUE) */ + /* ALTER TABLE xxx ADD [CONSTRAINT yyy] (PRIMARY KEY|UNIQUE) */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "PRIMARY", "KEY"): case Matches("ALTER", "TABLE", MatchAny, "ADD", "UNIQUE"): case Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny, "PRIMARY", "KEY"): case Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny, "UNIQUE"): - COMPLETE_WITH("(", "USING INDEX"); + COMPLETE_WITH("(", "USING INDEX"); break; - /* ALTER TABLE xxx ADD PRIMARY KEY USING INDEX */ + /* ALTER TABLE xxx ADD PRIMARY KEY USING INDEX */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "PRIMARY", "KEY", "USING", "INDEX"): - set_completion_reference(prev6_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); + set_completion_reference(prev6_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); break; - /* ALTER TABLE xxx ADD UNIQUE USING INDEX */ + /* ALTER TABLE xxx ADD UNIQUE USING INDEX */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "UNIQUE", "USING", "INDEX"): - set_completion_reference(prev5_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); + set_completion_reference(prev5_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); break; - /* ALTER TABLE xxx ADD CONSTRAINT yyy PRIMARY KEY USING INDEX */ + /* ALTER TABLE xxx ADD CONSTRAINT yyy PRIMARY KEY USING INDEX */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny, "PRIMARY", "KEY", "USING", "INDEX"): - set_completion_reference(prev8_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); + set_completion_reference(prev8_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); break; - /* ALTER TABLE xxx ADD CONSTRAINT yyy UNIQUE USING INDEX */ + /* ALTER TABLE xxx ADD CONSTRAINT yyy UNIQUE USING INDEX */ case Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny, "UNIQUE", "USING", "INDEX"): - set_completion_reference(prev7_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); + set_completion_reference(prev7_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table); break; - /* ALTER TABLE xxx ENABLE */ + /* ALTER TABLE xxx ENABLE */ case Matches("ALTER", "TABLE", MatchAny, "ENABLE"): - COMPLETE_WITH("ALWAYS", "REPLICA", "ROW LEVEL SECURITY", "RULE", - "TRIGGER"); + COMPLETE_WITH("ALWAYS", "REPLICA", "ROW LEVEL SECURITY", "RULE", + "TRIGGER"); break; case Matches("ALTER", "TABLE", MatchAny, "ENABLE", "REPLICA|ALWAYS"): - COMPLETE_WITH("RULE", "TRIGGER"); + COMPLETE_WITH("RULE", "TRIGGER"); break; case Matches("ALTER", "TABLE", MatchAny, "ENABLE", "RULE"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "ENABLE", MatchAny, "RULE"): - set_completion_reference(prev4_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table); + set_completion_reference(prev4_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "ENABLE", "TRIGGER"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "ENABLE", MatchAny, "TRIGGER"): - set_completion_reference(prev4_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table); + set_completion_reference(prev4_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table); break; - /* ALTER TABLE xxx INHERIT */ + /* ALTER TABLE xxx INHERIT */ case Matches("ALTER", "TABLE", MatchAny, "INHERIT"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* ALTER TABLE xxx NO */ + /* ALTER TABLE xxx NO */ case Matches("ALTER", "TABLE", MatchAny, "NO"): - COMPLETE_WITH("FORCE ROW LEVEL SECURITY", "INHERIT"); + COMPLETE_WITH("FORCE ROW LEVEL SECURITY", "INHERIT"); break; - /* ALTER TABLE xxx NO INHERIT */ + /* ALTER TABLE xxx NO INHERIT */ case Matches("ALTER", "TABLE", MatchAny, "NO", "INHERIT"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* ALTER TABLE xxx DISABLE */ + /* ALTER TABLE xxx DISABLE */ case Matches("ALTER", "TABLE", MatchAny, "DISABLE"): - COMPLETE_WITH("ROW LEVEL SECURITY", "RULE", "TRIGGER"); + COMPLETE_WITH("ROW LEVEL SECURITY", "RULE", "TRIGGER"); break; case Matches("ALTER", "TABLE", MatchAny, "DISABLE", "RULE"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "DISABLE", "TRIGGER"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table); break; - /* ALTER TABLE xxx ALTER */ + /* ALTER TABLE xxx ALTER */ case Matches("ALTER", "TABLE", MatchAny, "ALTER"): - COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "CONSTRAINT"); + COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "CONSTRAINT"); break; - /* ALTER TABLE xxx RENAME */ + /* ALTER TABLE xxx RENAME */ case Matches("ALTER", "TABLE", MatchAny, "RENAME"): - COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "CONSTRAINT", "TO"); + COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "CONSTRAINT", "TO"); break; case Matches("ALTER", "TABLE", MatchAny, "ALTER|RENAME", "COLUMN"): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; - /* ALTER TABLE xxx RENAME yyy */ + /* ALTER TABLE xxx RENAME yyy */ case Matches("ALTER", "TABLE", MatchAny, "RENAME", MatchAnyExcept("CONSTRAINT|TO")): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* ALTER TABLE xxx RENAME COLUMN/CONSTRAINT yyy */ + /* ALTER TABLE xxx RENAME COLUMN/CONSTRAINT yyy */ case Matches("ALTER", "TABLE", MatchAny, "RENAME", "COLUMN|CONSTRAINT", MatchAnyExcept("TO")): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* If we have ALTER TABLE DROP, provide COLUMN or CONSTRAINT */ + /* If we have ALTER TABLE DROP, provide COLUMN or CONSTRAINT */ case Matches("ALTER", "TABLE", MatchAny, "DROP"): - COMPLETE_WITH("COLUMN", "CONSTRAINT"); + COMPLETE_WITH("COLUMN", "CONSTRAINT"); break; - /* If we have ALTER TABLE DROP COLUMN, provide list of columns */ + + /* + * If we have ALTER TABLE DROP COLUMN, provide list of + * columns + */ case Matches("ALTER", "TABLE", MatchAny, "DROP", "COLUMN"): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; - /* ALTER TABLE ALTER|DROP|RENAME CONSTRAINT */ + /* ALTER TABLE ALTER|DROP|RENAME CONSTRAINT */ case Matches("ALTER", "TABLE", MatchAny, "ALTER|DROP|RENAME", "CONSTRAINT"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_table); break; - /* ALTER TABLE VALIDATE CONSTRAINT */ + + /* + * ALTER TABLE VALIDATE CONSTRAINT + */ case Matches("ALTER", "TABLE", MatchAny, "VALIDATE", "CONSTRAINT"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_table_not_validated); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_table_not_validated); break; - /* ALTER TABLE ALTER [COLUMN] */ + /* ALTER TABLE ALTER [COLUMN] */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny): - COMPLETE_WITH("TYPE", "SET", "RESET", "RESTART", "ADD", "DROP"); + COMPLETE_WITH("TYPE", "SET", "RESET", "RESTART", "ADD", "DROP"); break; - /* ALTER TABLE ALTER [COLUMN] ADD */ + /* ALTER TABLE ALTER [COLUMN] ADD */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD"): - COMPLETE_WITH("GENERATED"); + COMPLETE_WITH("GENERATED"); break; - /* ALTER TABLE ALTER [COLUMN] ADD GENERATED */ + /* ALTER TABLE ALTER [COLUMN] ADD GENERATED */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD", "GENERATED"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD", "GENERATED"): - COMPLETE_WITH("ALWAYS", "BY DEFAULT"); + COMPLETE_WITH("ALWAYS", "BY DEFAULT"); break; - /* ALTER TABLE ALTER [COLUMN] ADD GENERATED */ + /* ALTER TABLE ALTER [COLUMN] ADD GENERATED */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD", "GENERATED", "ALWAYS"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD", "GENERATED", "ALWAYS"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD", "GENERATED", "BY", "DEFAULT"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD", "GENERATED", "BY", "DEFAULT"): - COMPLETE_WITH("AS IDENTITY"); + COMPLETE_WITH("AS IDENTITY"); break; - /* ALTER TABLE ALTER [COLUMN] SET */ + /* ALTER TABLE ALTER [COLUMN] SET */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET"): - COMPLETE_WITH("(", "COMPRESSION", "DATA TYPE", "DEFAULT", "EXPRESSION", "GENERATED", "NOT NULL", - "STATISTICS", "STORAGE", - /* a subset of ALTER SEQUENCE options */ - "INCREMENT", "MINVALUE", "MAXVALUE", "START", "NO", "CACHE", "CYCLE"); + COMPLETE_WITH("(", "COMPRESSION", "DATA TYPE", "DEFAULT", "EXPRESSION", "GENERATED", "NOT NULL", + "STATISTICS", "STORAGE", + /* a subset of ALTER SEQUENCE options */ + "INCREMENT", "MINVALUE", "MAXVALUE", "START", "NO", "CACHE", "CYCLE"); break; - /* ALTER TABLE ALTER [COLUMN] SET ( */ + /* ALTER TABLE ALTER [COLUMN] SET ( */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "("): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "("): - COMPLETE_WITH("n_distinct", "n_distinct_inherited"); + COMPLETE_WITH("n_distinct", "n_distinct_inherited"); break; - /* ALTER TABLE ALTER [COLUMN] SET COMPRESSION */ + /* ALTER TABLE ALTER [COLUMN] SET COMPRESSION */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "COMPRESSION"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "COMPRESSION"): - COMPLETE_WITH("DEFAULT", "PGLZ", "LZ4"); + COMPLETE_WITH("DEFAULT", "PGLZ", "LZ4"); break; - /* ALTER TABLE ALTER [COLUMN] SET EXPRESSION */ + /* ALTER TABLE ALTER [COLUMN] SET EXPRESSION */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "EXPRESSION"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "EXPRESSION"): - COMPLETE_WITH("AS"); + COMPLETE_WITH("AS"); break; - /* ALTER TABLE ALTER [COLUMN] SET EXPRESSION AS */ + /* ALTER TABLE ALTER [COLUMN] SET EXPRESSION AS */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "EXPRESSION", "AS"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "EXPRESSION", "AS"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER TABLE ALTER [COLUMN] SET GENERATED */ + /* ALTER TABLE ALTER [COLUMN] SET GENERATED */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "GENERATED"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "GENERATED"): - COMPLETE_WITH("ALWAYS", "BY DEFAULT"); + COMPLETE_WITH("ALWAYS", "BY DEFAULT"); break; - /* ALTER TABLE ALTER [COLUMN] SET NO */ + /* ALTER TABLE ALTER [COLUMN] SET NO */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "NO"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "NO"): - COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE"); + COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE"); break; - /* ALTER TABLE ALTER [COLUMN] SET STORAGE */ + /* ALTER TABLE ALTER [COLUMN] SET STORAGE */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "STORAGE"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "STORAGE"): - COMPLETE_WITH("DEFAULT", "PLAIN", "EXTERNAL", "EXTENDED", "MAIN"); + COMPLETE_WITH("DEFAULT", "PLAIN", "EXTERNAL", "EXTENDED", "MAIN"); break; - /* ALTER TABLE ALTER [COLUMN] SET STATISTICS */ + /* ALTER TABLE ALTER [COLUMN] SET STATISTICS */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "STATISTICS"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "STATISTICS"): - /* Enforce no completion here, as an integer has to be specified */ + /* Enforce no completion here, as an integer has to be specified */ break; - /* ALTER TABLE ALTER [COLUMN] DROP */ + /* ALTER TABLE ALTER [COLUMN] DROP */ case Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "DROP"): case Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "DROP"): - COMPLETE_WITH("DEFAULT", "EXPRESSION", "IDENTITY", "NOT NULL"); + COMPLETE_WITH("DEFAULT", "EXPRESSION", "IDENTITY", "NOT NULL"); break; case Matches("ALTER", "TABLE", MatchAny, "CLUSTER"): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("ALTER", "TABLE", MatchAny, "CLUSTER", "ON"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table); break; - /* If we have ALTER TABLE SET, provide list of attributes and '(' */ + + /* + * If we have ALTER TABLE SET, provide list of attributes + * and '(' + */ case Matches("ALTER", "TABLE", MatchAny, "SET"): - COMPLETE_WITH("(", "ACCESS METHOD", "LOGGED", "SCHEMA", - "TABLESPACE", "UNLOGGED", "WITH", "WITHOUT"); + COMPLETE_WITH("(", "ACCESS METHOD", "LOGGED", "SCHEMA", + "TABLESPACE", "UNLOGGED", "WITH", "WITHOUT"); break; - /* - * If we have ALTER TABLE SET ACCESS METHOD provide a list of table - * AMs. - */ + /* + * If we have ALTER TABLE SET ACCESS METHOD provide a list + * of table AMs. + */ case Matches("ALTER", "TABLE", MatchAny, "SET", "ACCESS", "METHOD"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_table_access_methods, - "DEFAULT"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_table_access_methods, + "DEFAULT"); break; - /* - * If we have ALTER TABLE SET TABLESPACE provide a list of - * tablespaces - */ + /* + * If we have ALTER TABLE SET TABLESPACE provide a list of + * tablespaces + */ case Matches("ALTER", "TABLE", MatchAny, "SET", "TABLESPACE"): - COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); + COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); break; - /* If we have ALTER TABLE SET WITHOUT provide CLUSTER or OIDS */ + + /* + * If we have ALTER TABLE SET WITHOUT provide CLUSTER or + * OIDS + */ case Matches("ALTER", "TABLE", MatchAny, "SET", "WITHOUT"): - COMPLETE_WITH("CLUSTER", "OIDS"); + COMPLETE_WITH("CLUSTER", "OIDS"); break; - /* ALTER TABLE RESET */ + /* ALTER TABLE RESET */ case Matches("ALTER", "TABLE", MatchAny, "RESET"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER TABLE SET|RESET ( */ + /* ALTER TABLE SET|RESET ( */ case Matches("ALTER", "TABLE", MatchAny, "SET|RESET", "("): - COMPLETE_WITH_LIST(table_storage_parameters); + COMPLETE_WITH_LIST(table_storage_parameters); break; case Matches("ALTER", "TABLE", MatchAny, "REPLICA", "IDENTITY", "USING", "INDEX"): - set_completion_reference(prev5_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table); + set_completion_reference(prev5_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "REPLICA", "IDENTITY", "USING"): - COMPLETE_WITH("INDEX"); + COMPLETE_WITH("INDEX"); break; case Matches("ALTER", "TABLE", MatchAny, "REPLICA", "IDENTITY"): - COMPLETE_WITH("FULL", "NOTHING", "DEFAULT", "USING"); + COMPLETE_WITH("FULL", "NOTHING", "DEFAULT", "USING"); break; case Matches("ALTER", "TABLE", MatchAny, "REPLICA"): - COMPLETE_WITH("IDENTITY"); + COMPLETE_WITH("IDENTITY"); break; - /* - * If we have ALTER TABLE ATTACH PARTITION, provide a list of - * tables. - */ + /* + * If we have ALTER TABLE ATTACH PARTITION, provide a list + * of tables. + */ case Matches("ALTER", "TABLE", MatchAny, "ATTACH", "PARTITION"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* Limited completion support for partition bound specification */ + /* Limited completion support for partition bound specification */ case TailMatches("ATTACH", "PARTITION", MatchAny): - COMPLETE_WITH("FOR VALUES", "DEFAULT"); + COMPLETE_WITH("FOR VALUES", "DEFAULT"); break; case TailMatches("FOR", "VALUES"): - COMPLETE_WITH("FROM (", "IN (", "WITH ("); + COMPLETE_WITH("FROM (", "IN (", "WITH ("); break; - /* - * If we have ALTER TABLE DETACH|SPLIT PARTITION, provide a list of - * partitions of . - */ + /* + * If we have ALTER TABLE DETACH|SPLIT PARTITION, provide a + * list of partitions of . + */ case Matches("ALTER", "TABLE", MatchAny, "DETACH|SPLIT", "PARTITION"): - set_completion_reference(prev3_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_partition_of_table); + set_completion_reference(prev3_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_partition_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "DETACH", "PARTITION", MatchAny): - COMPLETE_WITH("CONCURRENTLY", "FINALIZE"); + COMPLETE_WITH("CONCURRENTLY", "FINALIZE"); break; - /* ALTER TABLE SPLIT PARTITION */ + /* ALTER TABLE SPLIT PARTITION */ case Matches("ALTER", "TABLE", MatchAny, "SPLIT", "PARTITION", MatchAny): - COMPLETE_WITH("INTO ( PARTITION"); + COMPLETE_WITH("INTO ( PARTITION"); break; - /* ALTER TABLE MERGE PARTITIONS ( */ + /* ALTER TABLE MERGE PARTITIONS ( */ case Matches("ALTER", "TABLE", MatchAny, "MERGE", "PARTITIONS", "("): - set_completion_reference(prev4_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_partition_of_table); + set_completion_reference(prev4_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_partition_of_table); break; case Matches("ALTER", "TABLE", MatchAny, "MERGE", "PARTITIONS", "(*)"): - COMPLETE_WITH("INTO"); + COMPLETE_WITH("INTO"); break; - /* ALTER TABLE OF */ + /* ALTER TABLE OF */ case Matches("ALTER", "TABLE", MatchAny, "OF"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_composite_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_composite_datatypes); break; - /* ALTER TABLESPACE with RENAME TO, OWNER TO, SET, RESET */ + /* ALTER TABLESPACE with RENAME TO, OWNER TO, SET, RESET */ case Matches("ALTER", "TABLESPACE", MatchAny): - COMPLETE_WITH("RENAME TO", "OWNER TO", "SET", "RESET"); + COMPLETE_WITH("RENAME TO", "OWNER TO", "SET", "RESET"); break; - /* ALTER TABLESPACE SET|RESET */ + /* ALTER TABLESPACE SET|RESET */ case Matches("ALTER", "TABLESPACE", MatchAny, "SET|RESET"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* ALTER TABLESPACE SET|RESET ( */ + /* ALTER TABLESPACE SET|RESET ( */ case Matches("ALTER", "TABLESPACE", MatchAny, "SET|RESET", "("): - COMPLETE_WITH("seq_page_cost", "random_page_cost", - "effective_io_concurrency", "maintenance_io_concurrency"); + COMPLETE_WITH("seq_page_cost", "random_page_cost", + "effective_io_concurrency", "maintenance_io_concurrency"); break; - /* ALTER TEXT SEARCH */ + /* ALTER TEXT SEARCH */ case Matches("ALTER", "TEXT", "SEARCH"): - COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); + COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); break; case Matches("ALTER", "TEXT", "SEARCH", "TEMPLATE|PARSER", MatchAny): - COMPLETE_WITH("RENAME TO", "SET SCHEMA"); + COMPLETE_WITH("RENAME TO", "SET SCHEMA"); break; case Matches("ALTER", "TEXT", "SEARCH", "DICTIONARY", MatchAny): - COMPLETE_WITH("(", "OWNER TO", "RENAME TO", "SET SCHEMA"); + COMPLETE_WITH("(", "OWNER TO", "RENAME TO", "SET SCHEMA"); break; case Matches("ALTER", "TEXT", "SEARCH", "CONFIGURATION", MatchAny): - COMPLETE_WITH("ADD MAPPING FOR", "ALTER MAPPING", - "DROP MAPPING FOR", - "OWNER TO", "RENAME TO", "SET SCHEMA"); + COMPLETE_WITH("ADD MAPPING FOR", "ALTER MAPPING", + "DROP MAPPING FOR", + "OWNER TO", "RENAME TO", "SET SCHEMA"); break; - /* complete ALTER TYPE with actions */ + /* complete ALTER TYPE with actions */ case Matches("ALTER", "TYPE", MatchAny): - COMPLETE_WITH("ADD ATTRIBUTE", "ADD VALUE", "ALTER ATTRIBUTE", - "DROP ATTRIBUTE", - "OWNER TO", "RENAME", "SET SCHEMA", "SET ("); + COMPLETE_WITH("ADD ATTRIBUTE", "ADD VALUE", "ALTER ATTRIBUTE", + "DROP ATTRIBUTE", + "OWNER TO", "RENAME", "SET SCHEMA", "SET ("); break; - /* complete ALTER TYPE ADD with actions */ + /* complete ALTER TYPE ADD with actions */ case Matches("ALTER", "TYPE", MatchAny, "ADD"): - COMPLETE_WITH("ATTRIBUTE", "VALUE"); + COMPLETE_WITH("ATTRIBUTE", "VALUE"); break; - /* ALTER TYPE RENAME */ + /* ALTER TYPE RENAME */ case Matches("ALTER", "TYPE", MatchAny, "RENAME"): - COMPLETE_WITH("ATTRIBUTE", "TO", "VALUE"); + COMPLETE_WITH("ATTRIBUTE", "TO", "VALUE"); break; - /* ALTER TYPE xxx RENAME (ATTRIBUTE|VALUE) yyy */ + /* ALTER TYPE xxx RENAME (ATTRIBUTE|VALUE) yyy */ case Matches("ALTER", "TYPE", MatchAny, "RENAME", "ATTRIBUTE|VALUE", MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* - * If we have ALTER TYPE ALTER/DROP/RENAME ATTRIBUTE, provide list - * of attributes - */ + /* + * If we have ALTER TYPE ALTER/DROP/RENAME ATTRIBUTE, + * provide list of attributes + */ case Matches("ALTER", "TYPE", MatchAny, "ALTER|DROP|RENAME", "ATTRIBUTE"): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; - /* ALTER TYPE ALTER ATTRIBUTE */ + /* ALTER TYPE ALTER ATTRIBUTE */ case Matches("ALTER", "TYPE", MatchAny, "ALTER", "ATTRIBUTE", MatchAny): - COMPLETE_WITH("TYPE"); + COMPLETE_WITH("TYPE"); break; - /* complete ALTER TYPE RENAME VALUE with list of enum values */ + /* complete ALTER TYPE RENAME VALUE with list of enum values */ case Matches("ALTER", "TYPE", MatchAny, "RENAME", "VALUE"): - COMPLETE_WITH_ENUM_VALUE(prev3_wd); + COMPLETE_WITH_ENUM_VALUE(prev3_wd); break; - /* ALTER TYPE SET */ + /* ALTER TYPE SET */ case Matches("ALTER", "TYPE", MatchAny, "SET"): - COMPLETE_WITH("(", "SCHEMA"); + COMPLETE_WITH("(", "SCHEMA"); break; - /* complete ALTER TYPE SET ( with settable properties */ + /* complete ALTER TYPE SET ( with settable properties */ case Matches("ALTER", "TYPE", MatchAny, "SET", "("): - COMPLETE_WITH("ANALYZE", "RECEIVE", "SEND", "STORAGE", "SUBSCRIPT", - "TYPMOD_IN", "TYPMOD_OUT"); + COMPLETE_WITH("ANALYZE", "RECEIVE", "SEND", "STORAGE", "SUBSCRIPT", + "TYPMOD_IN", "TYPMOD_OUT"); break; - /* complete ALTER GROUP */ + /* complete ALTER GROUP */ case Matches("ALTER", "GROUP", MatchAny): - COMPLETE_WITH("ADD USER", "DROP USER", "RENAME TO"); + COMPLETE_WITH("ADD USER", "DROP USER", "RENAME TO"); break; - /* complete ALTER GROUP ADD|DROP with USER */ + /* complete ALTER GROUP ADD|DROP with USER */ case Matches("ALTER", "GROUP", MatchAny, "ADD|DROP"): - COMPLETE_WITH("USER"); + COMPLETE_WITH("USER"); break; - /* complete ALTER GROUP ADD|DROP USER with a user name */ + /* complete ALTER GROUP ADD|DROP USER with a user name */ case Matches("ALTER", "GROUP", MatchAny, "ADD|DROP", "USER"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; /* @@ -3131,894 +3167,935 @@ match_previous_words(int pattern_id, * ANALYZE [ VERBOSE ] [ table_and_columns [, ...] ] */ case Matches("ANALYZE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_analyzables, - "VERBOSE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_analyzables, + "VERBOSE"); break; case HeadMatches("ANALYZE", "(*"): - if (!HeadMatches("ANALYZE", "(*)")) - { - /* - * This fires if we're in an unfinished parenthesized option list. - * get_previous_words treats a completed parenthesized option list as - * one word, so the above test is correct. - */ - if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) - COMPLETE_WITH("VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT"); - else if (TailMatches("VERBOSE|SKIP_LOCKED")) - COMPLETE_WITH("ON", "OFF"); - } + if (!HeadMatches("ANALYZE", "(*)")) + { + /* + * This fires if we're in an unfinished parenthesized option + * list. get_previous_words treats a completed parenthesized + * option list as one word, so the above test is correct. + */ + if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) + COMPLETE_WITH("VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT"); + else if (TailMatches("VERBOSE|SKIP_LOCKED")) + COMPLETE_WITH("ON", "OFF"); + } break; case Matches("ANALYZE", MatchAnyN, "("): - /* "ANALYZE (" should be caught above, so assume we want columns */ - COMPLETE_WITH_ATTR(prev2_wd); + /* "ANALYZE (" should be caught above, so assume we want columns */ + COMPLETE_WITH_ATTR(prev2_wd); break; case HeadMatches("ANALYZE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_analyzables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_analyzables); break; /* BEGIN */ case Matches("BEGIN"): - COMPLETE_WITH("WORK", "TRANSACTION", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE"); + COMPLETE_WITH("WORK", "TRANSACTION", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE"); break; /* END, ABORT */ case Matches("END|ABORT"): - COMPLETE_WITH("AND", "WORK", "TRANSACTION"); + COMPLETE_WITH("AND", "WORK", "TRANSACTION"); break; /* COMMIT */ case Matches("COMMIT"): - COMPLETE_WITH("AND", "WORK", "TRANSACTION", "PREPARED"); + COMPLETE_WITH("AND", "WORK", "TRANSACTION", "PREPARED"); break; /* RELEASE SAVEPOINT */ case Matches("RELEASE"): - COMPLETE_WITH("SAVEPOINT"); + COMPLETE_WITH("SAVEPOINT"); break; /* ROLLBACK */ case Matches("ROLLBACK"): - COMPLETE_WITH("AND", "WORK", "TRANSACTION", "TO SAVEPOINT", "PREPARED"); + COMPLETE_WITH("AND", "WORK", "TRANSACTION", "TO SAVEPOINT", "PREPARED"); break; case Matches("ABORT|END|COMMIT|ROLLBACK", "AND"): - COMPLETE_WITH("CHAIN"); + COMPLETE_WITH("CHAIN"); break; /* CALL */ case Matches("CALL"): - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures); + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures); break; case Matches("CALL", MatchAny): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; /* CLOSE */ case Matches("CLOSE"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, - "ALL"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, + "ALL"); break; /* CLUSTER */ case Matches("CLUSTER"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_clusterables, - "VERBOSE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_clusterables, + "VERBOSE"); break; case Matches("CLUSTER", "VERBOSE"): case Matches("CLUSTER", "(*)"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_clusterables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_clusterables); break; - /* If we have CLUSTER , then add "USING" */ + /* If we have CLUSTER , then add "USING" */ case Matches("CLUSTER", MatchAnyExcept("VERBOSE|ON|(|(*)")): - COMPLETE_WITH("USING"); + COMPLETE_WITH("USING"); break; - /* If we have CLUSTER VERBOSE , then add "USING" */ + /* If we have CLUSTER VERBOSE , then add "USING" */ case Matches("CLUSTER", "VERBOSE|(*)", MatchAny): - COMPLETE_WITH("USING"); + COMPLETE_WITH("USING"); break; - /* If we have CLUSTER USING, then add the index as well */ + /* If we have CLUSTER USING, then add the index as well */ case Matches("CLUSTER", MatchAny, "USING"): case Matches("CLUSTER", "VERBOSE|(*)", MatchAny, "USING"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table); break; case HeadMatches("CLUSTER", "(*"): - if (!HeadMatches("CLUSTER", "(*)")) - { - /* - * This fires if we're in an unfinished parenthesized option list. - * get_previous_words treats a completed parenthesized option list as - * one word, so the above test is correct. - */ - if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) - COMPLETE_WITH("VERBOSE"); - } + if (!HeadMatches("CLUSTER", "(*)")) + { + /* + * This fires if we're in an unfinished parenthesized option + * list. get_previous_words treats a completed parenthesized + * option list as one word, so the above test is correct. + */ + if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) + COMPLETE_WITH("VERBOSE"); + } break; /* COMMENT */ case Matches("COMMENT"): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("COMMENT", "ON"): - COMPLETE_WITH("ACCESS METHOD", "AGGREGATE", "CAST", "COLLATION", - "COLUMN", "CONSTRAINT", "CONVERSION", "DATABASE", - "DOMAIN", "EXTENSION", "EVENT TRIGGER", - "FOREIGN DATA WRAPPER", "FOREIGN TABLE", - "FUNCTION", "INDEX", "LANGUAGE", "LARGE OBJECT", - "MATERIALIZED VIEW", "OPERATOR", "POLICY", - "PROCEDURE", "PROCEDURAL LANGUAGE", "PUBLICATION", "ROLE", - "ROUTINE", "RULE", "SCHEMA", "SEQUENCE", "SERVER", - "STATISTICS", "SUBSCRIPTION", "TABLE", - "TABLESPACE", "TEXT SEARCH", "TRANSFORM FOR", - "TRIGGER", "TYPE", "VIEW"); + COMPLETE_WITH("ACCESS METHOD", "AGGREGATE", "CAST", "COLLATION", + "COLUMN", "CONSTRAINT", "CONVERSION", "DATABASE", + "DOMAIN", "EXTENSION", "EVENT TRIGGER", + "FOREIGN DATA WRAPPER", "FOREIGN TABLE", + "FUNCTION", "INDEX", "LANGUAGE", "LARGE OBJECT", + "MATERIALIZED VIEW", "OPERATOR", "POLICY", + "PROCEDURE", "PROCEDURAL LANGUAGE", "PUBLICATION", "ROLE", + "ROUTINE", "RULE", "SCHEMA", "SEQUENCE", "SERVER", + "STATISTICS", "SUBSCRIPTION", "TABLE", + "TABLESPACE", "TEXT SEARCH", "TRANSFORM FOR", + "TRIGGER", "TYPE", "VIEW"); break; case Matches("COMMENT", "ON", "ACCESS", "METHOD"): - COMPLETE_WITH_QUERY(Query_for_list_of_access_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_access_methods); break; case Matches("COMMENT", "ON", "CONSTRAINT"): - COMPLETE_WITH_QUERY(Query_for_all_table_constraints); + COMPLETE_WITH_QUERY(Query_for_all_table_constraints); break; case Matches("COMMENT", "ON", "CONSTRAINT", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("COMMENT", "ON", "CONSTRAINT", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables_for_constraint, - "DOMAIN"); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables_for_constraint, + "DOMAIN"); break; case Matches("COMMENT", "ON", "CONSTRAINT", MatchAny, "ON", "DOMAIN"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains); break; case Matches("COMMENT", "ON", "EVENT", "TRIGGER"): - COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); + COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); break; case Matches("COMMENT", "ON", "FOREIGN"): - COMPLETE_WITH("DATA WRAPPER", "TABLE"); + COMPLETE_WITH("DATA WRAPPER", "TABLE"); break; case Matches("COMMENT", "ON", "FOREIGN", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables); break; case Matches("COMMENT", "ON", "MATERIALIZED", "VIEW"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); break; case Matches("COMMENT", "ON", "POLICY"): - COMPLETE_WITH_QUERY(Query_for_list_of_policies); + COMPLETE_WITH_QUERY(Query_for_list_of_policies); break; case Matches("COMMENT", "ON", "POLICY", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("COMMENT", "ON", "POLICY", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy); break; case Matches("COMMENT", "ON", "PROCEDURAL", "LANGUAGE"): - COMPLETE_WITH_QUERY(Query_for_list_of_languages); + COMPLETE_WITH_QUERY(Query_for_list_of_languages); break; case Matches("COMMENT", "ON", "RULE", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("COMMENT", "ON", "RULE", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule); break; case Matches("COMMENT", "ON", "TEXT", "SEARCH"): - COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); + COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); break; case Matches("COMMENT", "ON", "TEXT", "SEARCH", "CONFIGURATION"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_configurations); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_configurations); break; case Matches("COMMENT", "ON", "TEXT", "SEARCH", "DICTIONARY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_dictionaries); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_dictionaries); break; case Matches("COMMENT", "ON", "TEXT", "SEARCH", "PARSER"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_parsers); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_parsers); break; case Matches("COMMENT", "ON", "TEXT", "SEARCH", "TEMPLATE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_templates); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_templates); break; case Matches("COMMENT", "ON", "TRANSFORM", "FOR"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case Matches("COMMENT", "ON", "TRANSFORM", "FOR", MatchAny): - COMPLETE_WITH("LANGUAGE"); + COMPLETE_WITH("LANGUAGE"); break; case Matches("COMMENT", "ON", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_QUERY(Query_for_list_of_languages); + set_completion_reference(prev2_wd); + COMPLETE_WITH_QUERY(Query_for_list_of_languages); break; case Matches("COMMENT", "ON", "TRIGGER", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("COMMENT", "ON", "TRIGGER", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger); break; case Matches("COMMENT", "ON", MatchAny, MatchAnyExcept("IS")): case Matches("COMMENT", "ON", MatchAny, MatchAny, MatchAnyExcept("IS")): case Matches("COMMENT", "ON", MatchAny, MatchAny, MatchAny, MatchAnyExcept("IS")): case Matches("COMMENT", "ON", MatchAny, MatchAny, MatchAny, MatchAny, MatchAnyExcept("IS")): - COMPLETE_WITH("IS"); + COMPLETE_WITH("IS"); break; /* COPY */ - /* - * If we have COPY, offer list of tables or "(" (Also cover the analogous - * backslash command). - */ + /* + * If we have COPY, offer list of tables or "(" (Also cover the + * analogous backslash command). + */ case Matches("COPY|\\copy"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, "("); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, "("); break; - /* Complete COPY ( with legal query commands */ + /* Complete COPY ( with legal query commands */ case Matches("COPY|\\copy", "("): - COMPLETE_WITH("SELECT", "TABLE", "VALUES", "INSERT INTO", "UPDATE", "DELETE FROM", "WITH"); + COMPLETE_WITH("SELECT", "TABLE", "VALUES", "INSERT INTO", "UPDATE", "DELETE FROM", "WITH"); break; - /* Complete COPY */ + /* Complete COPY */ case Matches("COPY|\\copy", MatchAny): - COMPLETE_WITH("FROM", "TO"); + COMPLETE_WITH("FROM", "TO"); break; - /* Complete COPY FROM|TO with filename */ + /* Complete COPY FROM|TO with filename */ case Matches("COPY", MatchAny, "FROM|TO"): - completion_charp = ""; - completion_force_quote = true; /* COPY requires quoted filename */ - matches = rl_completion_matches(text, complete_from_files); + completion_charp = ""; + completion_force_quote = true; /* COPY requires quoted filename */ + matches = rl_completion_matches(text, complete_from_files); break; case Matches("\\copy", MatchAny, "FROM|TO"): - completion_charp = ""; - completion_force_quote = false; - matches = rl_completion_matches(text, complete_from_files); + completion_charp = ""; + completion_force_quote = false; + matches = rl_completion_matches(text, complete_from_files); break; - /* Complete COPY TO */ + /* Complete COPY TO */ case Matches("COPY|\\copy", MatchAny, "TO", MatchAny): - COMPLETE_WITH("WITH ("); + COMPLETE_WITH("WITH ("); break; - /* Complete COPY FROM */ + /* Complete COPY FROM */ case Matches("COPY|\\copy", MatchAny, "FROM", MatchAny): - COMPLETE_WITH("WITH (", "WHERE"); + COMPLETE_WITH("WITH (", "WHERE"); break; - /* Complete COPY FROM|TO filename WITH ( */ + /* Complete COPY FROM|TO filename WITH ( */ case Matches("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "WITH", "("): - COMPLETE_WITH("FORMAT", "FREEZE", "DELIMITER", "NULL", - "HEADER", "QUOTE", "ESCAPE", "FORCE_QUOTE", - "FORCE_NOT_NULL", "FORCE_NULL", "ENCODING", "DEFAULT", - "ON_ERROR", "LOG_VERBOSITY"); + COMPLETE_WITH("FORMAT", "FREEZE", "DELIMITER", "NULL", + "HEADER", "QUOTE", "ESCAPE", "FORCE_QUOTE", + "FORCE_NOT_NULL", "FORCE_NULL", "ENCODING", "DEFAULT", + "ON_ERROR", "LOG_VERBOSITY"); break; - /* Complete COPY FROM|TO filename WITH (FORMAT */ + /* Complete COPY FROM|TO filename WITH (FORMAT */ case Matches("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "WITH", "(", "FORMAT"): - COMPLETE_WITH("binary", "csv", "text"); + COMPLETE_WITH("binary", "csv", "text"); break; - /* Complete COPY FROM filename WITH (ON_ERROR */ + /* Complete COPY FROM filename WITH (ON_ERROR */ case Matches("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "WITH", "(", "ON_ERROR"): - COMPLETE_WITH("stop", "ignore"); + COMPLETE_WITH("stop", "ignore"); break; - /* Complete COPY FROM filename WITH (LOG_VERBOSITY */ + /* Complete COPY FROM filename WITH (LOG_VERBOSITY */ case Matches("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "WITH", "(", "LOG_VERBOSITY"): - COMPLETE_WITH("default", "verbose"); + COMPLETE_WITH("default", "verbose"); break; - /* Complete COPY FROM WITH () */ + /* Complete COPY FROM WITH () */ case Matches("COPY|\\copy", MatchAny, "FROM", MatchAny, "WITH", MatchAny): - COMPLETE_WITH("WHERE"); + COMPLETE_WITH("WHERE"); break; - /* CREATE ACCESS METHOD */ - /* Complete "CREATE ACCESS METHOD " */ + /* CREATE ACCESS METHOD */ + /* Complete "CREATE ACCESS METHOD " */ case Matches("CREATE", "ACCESS", "METHOD", MatchAny): - COMPLETE_WITH("TYPE"); + COMPLETE_WITH("TYPE"); break; - /* Complete "CREATE ACCESS METHOD TYPE" */ + /* Complete "CREATE ACCESS METHOD TYPE" */ case Matches("CREATE", "ACCESS", "METHOD", MatchAny, "TYPE"): - COMPLETE_WITH("INDEX", "TABLE"); + COMPLETE_WITH("INDEX", "TABLE"); break; - /* Complete "CREATE ACCESS METHOD TYPE " */ + /* Complete "CREATE ACCESS METHOD TYPE " */ case Matches("CREATE", "ACCESS", "METHOD", MatchAny, "TYPE", MatchAny): - COMPLETE_WITH("HANDLER"); + COMPLETE_WITH("HANDLER"); break; - /* CREATE COLLATION */ + /* CREATE COLLATION */ case Matches("CREATE", "COLLATION", MatchAny): - COMPLETE_WITH("(", "FROM"); + COMPLETE_WITH("(", "FROM"); break; case Matches("CREATE", "COLLATION", MatchAny, "FROM"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_collations); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_collations); break; case HeadMatches("CREATE", "COLLATION", MatchAny, "(*"): - if (TailMatches("(|*,")) - COMPLETE_WITH("LOCALE =", "LC_COLLATE =", "LC_CTYPE =", - "PROVIDER =", "DETERMINISTIC ="); - else if (TailMatches("PROVIDER", "=")) - COMPLETE_WITH("libc", "icu"); - else if (TailMatches("DETERMINISTIC", "=")) - COMPLETE_WITH("true", "false"); + if (TailMatches("(|*,")) + COMPLETE_WITH("LOCALE =", "LC_COLLATE =", "LC_CTYPE =", + "PROVIDER =", "DETERMINISTIC ="); + else if (TailMatches("PROVIDER", "=")) + COMPLETE_WITH("libc", "icu"); + else if (TailMatches("DETERMINISTIC", "=")) + COMPLETE_WITH("true", "false"); break; - /* CREATE DATABASE */ + /* CREATE DATABASE */ case Matches("CREATE", "DATABASE", MatchAny): - COMPLETE_WITH("OWNER", "TEMPLATE", "ENCODING", "TABLESPACE", - "IS_TEMPLATE", "STRATEGY", - "ALLOW_CONNECTIONS", "CONNECTION LIMIT", - "LC_COLLATE", "LC_CTYPE", "LOCALE", "OID", - "LOCALE_PROVIDER", "ICU_LOCALE"); + COMPLETE_WITH("OWNER", "TEMPLATE", "ENCODING", "TABLESPACE", + "IS_TEMPLATE", "STRATEGY", + "ALLOW_CONNECTIONS", "CONNECTION LIMIT", + "LC_COLLATE", "LC_CTYPE", "LOCALE", "OID", + "LOCALE_PROVIDER", "ICU_LOCALE"); break; case Matches("CREATE", "DATABASE", MatchAny, "TEMPLATE"): - COMPLETE_WITH_QUERY(Query_for_list_of_template_databases); + COMPLETE_WITH_QUERY(Query_for_list_of_template_databases); break; case Matches("CREATE", "DATABASE", MatchAny, "STRATEGY"): - COMPLETE_WITH("WAL_LOG", "FILE_COPY"); + COMPLETE_WITH("WAL_LOG", "FILE_COPY"); break; - /* CREATE DOMAIN */ + /* CREATE DOMAIN */ case Matches("CREATE", "DOMAIN", MatchAny): - COMPLETE_WITH("AS"); + COMPLETE_WITH("AS"); break; case Matches("CREATE", "DOMAIN", MatchAny, "AS"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case Matches("CREATE", "DOMAIN", MatchAny, "AS", MatchAny): - COMPLETE_WITH("COLLATE", "DEFAULT", "CONSTRAINT", - "NOT NULL", "NULL", "CHECK ("); + COMPLETE_WITH("COLLATE", "DEFAULT", "CONSTRAINT", + "NOT NULL", "NULL", "CHECK ("); break; case Matches("CREATE", "DOMAIN", MatchAny, "COLLATE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_collations); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_collations); break; - /* CREATE EXTENSION */ - /* Complete with available extensions rather than installed ones. */ + /* CREATE EXTENSION */ + /* Complete with available extensions rather than installed ones. */ case Matches("CREATE", "EXTENSION"): - COMPLETE_WITH_QUERY(Query_for_list_of_available_extensions); + COMPLETE_WITH_QUERY(Query_for_list_of_available_extensions); break; - /* CREATE EXTENSION */ + /* CREATE EXTENSION */ case Matches("CREATE", "EXTENSION", MatchAny): - COMPLETE_WITH("WITH SCHEMA", "CASCADE", "VERSION"); + COMPLETE_WITH("WITH SCHEMA", "CASCADE", "VERSION"); break; - /* CREATE EXTENSION VERSION */ + /* CREATE EXTENSION VERSION */ case Matches("CREATE", "EXTENSION", MatchAny, "VERSION"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions); + set_completion_reference(prev2_wd); + COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions); break; - /* CREATE FOREIGN */ + /* CREATE FOREIGN */ case Matches("CREATE", "FOREIGN"): - COMPLETE_WITH("DATA WRAPPER", "TABLE"); + COMPLETE_WITH("DATA WRAPPER", "TABLE"); break; - /* CREATE FOREIGN DATA WRAPPER */ + /* CREATE FOREIGN DATA WRAPPER */ case Matches("CREATE", "FOREIGN", "DATA", "WRAPPER", MatchAny): - COMPLETE_WITH("HANDLER", "VALIDATOR", "OPTIONS"); + COMPLETE_WITH("HANDLER", "VALIDATOR", "OPTIONS"); break; - /* CREATE FOREIGN TABLE */ + /* CREATE FOREIGN TABLE */ case Matches("CREATE", "FOREIGN", "TABLE", MatchAny): - COMPLETE_WITH("(", "PARTITION OF"); + COMPLETE_WITH("(", "PARTITION OF"); break; - /* CREATE INDEX --- is allowed inside CREATE SCHEMA, so use TailMatches */ - /* First off we complete CREATE UNIQUE with "INDEX" */ + /* + * CREATE INDEX --- is allowed inside CREATE SCHEMA, so use + * TailMatches + */ + /* First off we complete CREATE UNIQUE with "INDEX" */ case TailMatches("CREATE", "UNIQUE"): - COMPLETE_WITH("INDEX"); + COMPLETE_WITH("INDEX"); break; - /* - * If we have CREATE|UNIQUE INDEX, then add "ON", "CONCURRENTLY", and - * existing indexes - */ + /* + * If we have CREATE|UNIQUE INDEX, then add "ON", "CONCURRENTLY", + * and existing indexes + */ case TailMatches("CREATE|UNIQUE", "INDEX"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, - "ON", "CONCURRENTLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, + "ON", "CONCURRENTLY"); break; - /* - * Complete ... INDEX|CONCURRENTLY [] ON with a list of relations - * that indexes can be created on - */ + /* + * Complete ... INDEX|CONCURRENTLY [] ON with a list of + * relations that indexes can be created on + */ case TailMatches("INDEX|CONCURRENTLY", MatchAny, "ON"): case TailMatches("INDEX|CONCURRENTLY", "ON"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexables); break; - /* - * Complete CREATE|UNIQUE INDEX CONCURRENTLY with "ON" and existing - * indexes - */ + /* + * Complete CREATE|UNIQUE INDEX CONCURRENTLY with "ON" and + * existing indexes + */ case TailMatches("CREATE|UNIQUE", "INDEX", "CONCURRENTLY"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, - "ON"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, + "ON"); break; - /* Complete CREATE|UNIQUE INDEX [CONCURRENTLY] with "ON" */ + /* Complete CREATE|UNIQUE INDEX [CONCURRENTLY] with "ON" */ case TailMatches("CREATE|UNIQUE", "INDEX", MatchAny): case TailMatches("CREATE|UNIQUE", "INDEX", "CONCURRENTLY", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* - * Complete INDEX ON
with a list of table columns (which - * should really be in parens) - */ + /* + * Complete INDEX ON
with a list of table columns + * (which should really be in parens) + */ case TailMatches("INDEX", MatchAny, "ON", MatchAny): case TailMatches("INDEX|CONCURRENTLY", "ON", MatchAny): - COMPLETE_WITH("(", "USING"); + COMPLETE_WITH("(", "USING"); break; case TailMatches("INDEX", MatchAny, "ON", MatchAny, "("): case TailMatches("INDEX|CONCURRENTLY", "ON", MatchAny, "("): - COMPLETE_WITH_ATTR(prev2_wd); + COMPLETE_WITH_ATTR(prev2_wd); break; - /* same if you put in USING */ + /* same if you put in USING */ case TailMatches("ON", MatchAny, "USING", MatchAny, "("): - COMPLETE_WITH_ATTR(prev4_wd); + COMPLETE_WITH_ATTR(prev4_wd); break; - /* Complete USING with an index method */ + /* Complete USING with an index method */ case TailMatches("INDEX", MatchAny, MatchAny, "ON", MatchAny, "USING"): case TailMatches("INDEX", MatchAny, "ON", MatchAny, "USING"): case TailMatches("INDEX", "ON", MatchAny, "USING"): - COMPLETE_WITH_QUERY(Query_for_list_of_index_access_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_index_access_methods); break; case TailMatches("ON", MatchAny, "USING", MatchAny): - if (!TailMatches("POLICY", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny) && !TailMatches("FOR", MatchAny, MatchAny, MatchAny)) - COMPLETE_WITH("("); + if (!TailMatches("POLICY", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny) && !TailMatches("FOR", MatchAny, MatchAny, MatchAny)) + COMPLETE_WITH("("); break; - /* CREATE OR REPLACE */ + /* CREATE OR REPLACE */ case Matches("CREATE", "OR"): - COMPLETE_WITH("REPLACE"); + COMPLETE_WITH("REPLACE"); break; - /* CREATE POLICY */ - /* Complete "CREATE POLICY ON" */ + /* CREATE POLICY */ + /* Complete "CREATE POLICY ON" */ case Matches("CREATE", "POLICY", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* Complete "CREATE POLICY ON
" */ + /* Complete "CREATE POLICY ON
" */ case Matches("CREATE", "POLICY", MatchAny, "ON"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* Complete "CREATE POLICY ON
AS|FOR|TO|USING|WITH CHECK" */ + + /* + * Complete "CREATE POLICY ON
AS|FOR|TO|USING|WITH + * CHECK" + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny): - COMPLETE_WITH("AS", "FOR", "TO", "USING (", "WITH CHECK ("); + COMPLETE_WITH("AS", "FOR", "TO", "USING (", "WITH CHECK ("); break; - /* CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE */ + /* CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS"): - COMPLETE_WITH("PERMISSIVE", "RESTRICTIVE"); + COMPLETE_WITH("PERMISSIVE", "RESTRICTIVE"); break; - /* - * CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE - * FOR|TO|USING|WITH CHECK - */ + /* + * CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE + * FOR|TO|USING|WITH CHECK + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny): - COMPLETE_WITH("FOR", "TO", "USING", "WITH CHECK"); + COMPLETE_WITH("FOR", "TO", "USING", "WITH CHECK"); break; - /* CREATE POLICY ON
FOR ALL|SELECT|INSERT|UPDATE|DELETE */ + + /* + * CREATE POLICY ON
FOR + * ALL|SELECT|INSERT|UPDATE|DELETE + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR"): - COMPLETE_WITH("ALL", "SELECT", "INSERT", "UPDATE", "DELETE"); + COMPLETE_WITH("ALL", "SELECT", "INSERT", "UPDATE", "DELETE"); break; - /* Complete "CREATE POLICY ON
FOR INSERT TO|WITH CHECK" */ + + /* + * Complete "CREATE POLICY ON
FOR INSERT TO|WITH + * CHECK" + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR", "INSERT"): - COMPLETE_WITH("TO", "WITH CHECK ("); + COMPLETE_WITH("TO", "WITH CHECK ("); break; - /* Complete "CREATE POLICY ON
FOR SELECT|DELETE TO|USING" */ + + /* + * Complete "CREATE POLICY ON
FOR SELECT|DELETE + * TO|USING" + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR", "SELECT|DELETE"): - COMPLETE_WITH("TO", "USING ("); + COMPLETE_WITH("TO", "USING ("); break; - /* CREATE POLICY ON
FOR ALL|UPDATE TO|USING|WITH CHECK */ + + /* + * CREATE POLICY ON
FOR ALL|UPDATE TO|USING|WITH + * CHECK + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR", "ALL|UPDATE"): - COMPLETE_WITH("TO", "USING (", "WITH CHECK ("); + COMPLETE_WITH("TO", "USING (", "WITH CHECK ("); break; - /* Complete "CREATE POLICY ON
TO " */ + /* Complete "CREATE POLICY ON
TO " */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "TO"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_grant_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_grant_roles); break; - /* Complete "CREATE POLICY ON
USING (" */ + /* Complete "CREATE POLICY ON
USING (" */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "USING"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; - /* - * CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE FOR - * ALL|SELECT|INSERT|UPDATE|DELETE - */ + /* + * CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE FOR + * ALL|SELECT|INSERT|UPDATE|DELETE + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR"): - COMPLETE_WITH("ALL", "SELECT", "INSERT", "UPDATE", "DELETE"); + COMPLETE_WITH("ALL", "SELECT", "INSERT", "UPDATE", "DELETE"); break; - /* - * Complete "CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE FOR - * INSERT TO|WITH CHECK" - */ + /* + * Complete "CREATE POLICY ON
AS + * PERMISSIVE|RESTRICTIVE FOR INSERT TO|WITH CHECK" + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR", "INSERT"): - COMPLETE_WITH("TO", "WITH CHECK ("); + COMPLETE_WITH("TO", "WITH CHECK ("); break; - /* - * Complete "CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE FOR - * SELECT|DELETE TO|USING" - */ + /* + * Complete "CREATE POLICY ON
AS + * PERMISSIVE|RESTRICTIVE FOR SELECT|DELETE TO|USING" + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR", "SELECT|DELETE"): - COMPLETE_WITH("TO", "USING ("); + COMPLETE_WITH("TO", "USING ("); break; - /* - * CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE FOR - * ALL|UPDATE TO|USING|WITH CHECK - */ + /* + * CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE FOR + * ALL|UPDATE TO|USING|WITH CHECK + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR", "ALL|UPDATE"): - COMPLETE_WITH("TO", "USING (", "WITH CHECK ("); + COMPLETE_WITH("TO", "USING (", "WITH CHECK ("); break; - /* - * Complete "CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE TO - * " - */ + /* + * Complete "CREATE POLICY ON
AS + * PERMISSIVE|RESTRICTIVE TO " + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "TO"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_grant_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_grant_roles); break; - /* - * Complete "CREATE POLICY ON
AS PERMISSIVE|RESTRICTIVE - * USING (" - */ + /* + * Complete "CREATE POLICY ON
AS + * PERMISSIVE|RESTRICTIVE USING (" + */ case Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "USING"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; /* CREATE PUBLICATION */ case Matches("CREATE", "PUBLICATION", MatchAny): - COMPLETE_WITH("FOR TABLE", "FOR ALL TABLES", "FOR TABLES IN SCHEMA", "WITH ("); + COMPLETE_WITH("FOR TABLE", "FOR ALL TABLES", "FOR TABLES IN SCHEMA", "WITH ("); break; case Matches("CREATE", "PUBLICATION", MatchAny, "FOR"): - COMPLETE_WITH("TABLE", "ALL TABLES", "TABLES IN SCHEMA"); + COMPLETE_WITH("TABLE", "ALL TABLES", "TABLES IN SCHEMA"); break; case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "ALL"): - COMPLETE_WITH("TABLES"); + COMPLETE_WITH("TABLES"); break; case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "ALL", "TABLES"): - COMPLETE_WITH("WITH ("); + COMPLETE_WITH("WITH ("); break; case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLES"): - COMPLETE_WITH("IN SCHEMA"); + COMPLETE_WITH("IN SCHEMA"); break; case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLE", MatchAny): - if (!ends_with(prev_wd, ',')) - COMPLETE_WITH("WHERE (", "WITH ("); + if (!ends_with(prev_wd, ',')) + COMPLETE_WITH("WHERE (", "WITH ("); break; - /* Complete "CREATE PUBLICATION FOR TABLE" with "
, ..." */ + + /* + * Complete "CREATE PUBLICATION FOR TABLE" with "
, + * ..." + */ case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* - * "CREATE PUBLICATION FOR TABLE WHERE (" - complete with - * table attributes - */ + /* + * "CREATE PUBLICATION FOR TABLE WHERE (" - complete + * with table attributes + */ case Matches("CREATE", "PUBLICATION", MatchAny, MatchAnyN, "WHERE"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; case Matches("CREATE", "PUBLICATION", MatchAny, MatchAnyN, "WHERE", "("): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; case Matches("CREATE", "PUBLICATION", MatchAny, MatchAnyN, "WHERE", "(*)"): - COMPLETE_WITH(" WITH ("); + COMPLETE_WITH(" WITH ("); break; - /* - * Complete "CREATE PUBLICATION FOR TABLES IN SCHEMA , ..." - */ + /* + * Complete "CREATE PUBLICATION FOR TABLES IN SCHEMA + * , ..." + */ case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLES", "IN", "SCHEMA"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas - " AND nspname NOT LIKE E'pg\\\\_%%'", - "CURRENT_SCHEMA"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas + " AND nspname NOT LIKE E'pg\\\\_%%'", + "CURRENT_SCHEMA"); break; case Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLES", "IN", "SCHEMA", MatchAny): - if ((!ends_with(prev_wd, ','))) - COMPLETE_WITH("WITH ("); + if ((!ends_with(prev_wd, ','))) + COMPLETE_WITH("WITH ("); break; - /* Complete "CREATE PUBLICATION [...] WITH" */ + /* Complete "CREATE PUBLICATION [...] WITH" */ case Matches("CREATE", "PUBLICATION", MatchAnyN, "WITH", "("): - COMPLETE_WITH("publish", "publish_via_partition_root"); + COMPLETE_WITH("publish", "publish_via_partition_root"); break; /* CREATE RULE */ - /* Complete "CREATE [ OR REPLACE ] RULE " with "AS ON" */ + /* Complete "CREATE [ OR REPLACE ] RULE " with "AS ON" */ case Matches("CREATE", "RULE", MatchAny): case Matches("CREATE", "OR", "REPLACE", "RULE", MatchAny): - COMPLETE_WITH("AS ON"); + COMPLETE_WITH("AS ON"); break; - /* Complete "CREATE [ OR REPLACE ] RULE AS" with "ON" */ + /* Complete "CREATE [ OR REPLACE ] RULE AS" with "ON" */ case Matches("CREATE", "RULE", MatchAny, "AS"): case Matches("CREATE", "OR", "REPLACE", "RULE", MatchAny, "AS"): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* - * Complete "CREATE [ OR REPLACE ] RULE AS ON" with - * SELECT|UPDATE|INSERT|DELETE - */ + /* + * Complete "CREATE [ OR REPLACE ] RULE AS ON" with + * SELECT|UPDATE|INSERT|DELETE + */ case Matches("CREATE", "RULE", MatchAny, "AS", "ON"): case Matches("CREATE", "OR", "REPLACE", "RULE", MatchAny, "AS", "ON"): - COMPLETE_WITH("SELECT", "UPDATE", "INSERT", "DELETE"); + COMPLETE_WITH("SELECT", "UPDATE", "INSERT", "DELETE"); break; - /* Complete "AS ON SELECT|UPDATE|INSERT|DELETE" with a "TO" */ + /* Complete "AS ON SELECT|UPDATE|INSERT|DELETE" with a "TO" */ case TailMatches("AS", "ON", "SELECT|UPDATE|INSERT|DELETE"): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* Complete "AS ON TO" with a table name */ + /* Complete "AS ON TO" with a table name */ case TailMatches("AS", "ON", "SELECT|UPDATE|INSERT|DELETE", "TO"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; /* CREATE SCHEMA [ ] [ AUTHORIZATION ] */ case Matches("CREATE", "SCHEMA"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas, - "AUTHORIZATION"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas, + "AUTHORIZATION"); break; case Matches("CREATE", "SCHEMA", "AUTHORIZATION"): case Matches("CREATE", "SCHEMA", MatchAny, "AUTHORIZATION"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_owner_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_owner_roles); break; case Matches("CREATE", "SCHEMA", "AUTHORIZATION", MatchAny): case Matches("CREATE", "SCHEMA", MatchAny, "AUTHORIZATION", MatchAny): - COMPLETE_WITH("CREATE", "GRANT"); + COMPLETE_WITH("CREATE", "GRANT"); break; case Matches("CREATE", "SCHEMA", MatchAny): - COMPLETE_WITH("AUTHORIZATION", "CREATE", "GRANT"); + COMPLETE_WITH("AUTHORIZATION", "CREATE", "GRANT"); break; /* CREATE SEQUENCE --- is allowed inside CREATE SCHEMA, so use TailMatches */ case TailMatches("CREATE", "SEQUENCE", MatchAny): case TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny): - COMPLETE_WITH("AS", "INCREMENT BY", "MINVALUE", "MAXVALUE", "NO", - "CACHE", "CYCLE", "OWNED BY", "START WITH"); + COMPLETE_WITH("AS", "INCREMENT BY", "MINVALUE", "MAXVALUE", "NO", + "CACHE", "CYCLE", "OWNED BY", "START WITH"); break; case TailMatches("CREATE", "SEQUENCE", MatchAny, "AS"): case TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny, "AS"): - COMPLETE_WITH_CS("smallint", "integer", "bigint"); + COMPLETE_WITH_CS("smallint", "integer", "bigint"); break; case TailMatches("CREATE", "SEQUENCE", MatchAny, "NO"): case TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny, "NO"): - COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE"); + COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE"); break; /* CREATE SERVER */ case Matches("CREATE", "SERVER", MatchAny): - COMPLETE_WITH("TYPE", "VERSION", "FOREIGN DATA WRAPPER"); + COMPLETE_WITH("TYPE", "VERSION", "FOREIGN DATA WRAPPER"); break; /* CREATE STATISTICS */ case Matches("CREATE", "STATISTICS", MatchAny): - COMPLETE_WITH("(", "ON"); + COMPLETE_WITH("(", "ON"); break; case Matches("CREATE", "STATISTICS", MatchAny, "("): - COMPLETE_WITH("ndistinct", "dependencies", "mcv"); + COMPLETE_WITH("ndistinct", "dependencies", "mcv"); break; case Matches("CREATE", "STATISTICS", MatchAny, "(*)"): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("CREATE", "STATISTICS", MatchAny, MatchAnyN, "FROM"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; /* CREATE TABLE --- is allowed inside CREATE SCHEMA, so use TailMatches */ - /* Complete "CREATE TEMP/TEMPORARY" with the possible temp objects */ + /* Complete "CREATE TEMP/TEMPORARY" with the possible temp objects */ case TailMatches("CREATE", "TEMP|TEMPORARY"): - COMPLETE_WITH("SEQUENCE", "TABLE", "VIEW"); + COMPLETE_WITH("SEQUENCE", "TABLE", "VIEW"); break; - /* Complete "CREATE UNLOGGED" with TABLE, SEQUENCE or MATVIEW */ + /* Complete "CREATE UNLOGGED" with TABLE, SEQUENCE or MATVIEW */ case TailMatches("CREATE", "UNLOGGED"): - /* but not MATVIEW in CREATE SCHEMA */ - if (HeadMatches("CREATE", "SCHEMA")) - COMPLETE_WITH("TABLE", "SEQUENCE"); - else - COMPLETE_WITH("TABLE", "SEQUENCE", "MATERIALIZED VIEW"); + /* but not MATVIEW in CREATE SCHEMA */ + if (HeadMatches("CREATE", "SCHEMA")) + COMPLETE_WITH("TABLE", "SEQUENCE"); + else + COMPLETE_WITH("TABLE", "SEQUENCE", "MATERIALIZED VIEW"); break; - /* Complete PARTITION BY with RANGE ( or LIST ( or ... */ + /* Complete PARTITION BY with RANGE ( or LIST ( or ... */ case TailMatches("PARTITION", "BY"): - COMPLETE_WITH("RANGE (", "LIST (", "HASH ("); + COMPLETE_WITH("RANGE (", "LIST (", "HASH ("); break; - /* If we have xxx PARTITION OF, provide a list of partitioned tables */ + + /* + * If we have xxx PARTITION OF, provide a list of partitioned + * tables + */ case TailMatches("PARTITION", "OF"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables); break; - /* Limited completion support for partition bound specification */ + /* Limited completion support for partition bound specification */ case TailMatches("PARTITION", "OF", MatchAny): - COMPLETE_WITH("FOR VALUES", "DEFAULT"); + COMPLETE_WITH("FOR VALUES", "DEFAULT"); break; - /* Complete CREATE TABLE with '(', AS, OF or PARTITION OF */ + /* Complete CREATE TABLE with '(', AS, OF or PARTITION OF */ case TailMatches("CREATE", "TABLE", MatchAny): case TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny): - COMPLETE_WITH("(", "AS", "OF", "PARTITION OF"); + COMPLETE_WITH("(", "AS", "OF", "PARTITION OF"); break; - /* Complete CREATE TABLE OF with list of composite types */ + /* Complete CREATE TABLE OF with list of composite types */ case TailMatches("CREATE", "TABLE", MatchAny, "OF"): case TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "OF"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_composite_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_composite_datatypes); break; - /* Complete CREATE TABLE [ (...) ] AS with list of keywords */ + /* Complete CREATE TABLE [ (...) ] AS with list of keywords */ case TailMatches("CREATE", "TABLE", MatchAny, "AS"): case TailMatches("CREATE", "TABLE", MatchAny, "(*)", "AS"): case TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "AS"): case TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "(*)", "AS"): - COMPLETE_WITH("EXECUTE", "SELECT", "TABLE", "VALUES", "WITH"); + COMPLETE_WITH("EXECUTE", "SELECT", "TABLE", "VALUES", "WITH"); break; - /* Complete CREATE TABLE name (...) with supported options */ + /* Complete CREATE TABLE name (...) with supported options */ case TailMatches("CREATE", "TABLE", MatchAny, "(*)"): case TailMatches("CREATE", "UNLOGGED", "TABLE", MatchAny, "(*)"): - COMPLETE_WITH("AS", "INHERITS (", "PARTITION BY", "USING", "TABLESPACE", "WITH ("); + COMPLETE_WITH("AS", "INHERITS (", "PARTITION BY", "USING", "TABLESPACE", "WITH ("); break; case TailMatches("CREATE", "TEMP|TEMPORARY", "TABLE", MatchAny, "(*)"): - COMPLETE_WITH("AS", "INHERITS (", "ON COMMIT", "PARTITION BY", - "TABLESPACE", "WITH ("); + COMPLETE_WITH("AS", "INHERITS (", "ON COMMIT", "PARTITION BY", + "TABLESPACE", "WITH ("); break; - /* Complete CREATE TABLE (...) USING with table access methods */ + /* Complete CREATE TABLE (...) USING with table access methods */ case TailMatches("CREATE", "TABLE", MatchAny, "(*)", "USING"): case TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "(*)", "USING"): - COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods); break; - /* Complete CREATE TABLE (...) WITH with storage parameters */ + /* Complete CREATE TABLE (...) WITH with storage parameters */ case TailMatches("CREATE", "TABLE", MatchAny, "(*)", "WITH", "("): case TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "(*)", "WITH", "("): - COMPLETE_WITH_LIST(table_storage_parameters); + COMPLETE_WITH_LIST(table_storage_parameters); break; - /* Complete CREATE TABLE ON COMMIT with actions */ + /* Complete CREATE TABLE ON COMMIT with actions */ case TailMatches("CREATE", "TEMP|TEMPORARY", "TABLE", MatchAny, "(*)", "ON", "COMMIT"): - COMPLETE_WITH("DELETE ROWS", "DROP", "PRESERVE ROWS"); + COMPLETE_WITH("DELETE ROWS", "DROP", "PRESERVE ROWS"); break; /* CREATE TABLESPACE */ case Matches("CREATE", "TABLESPACE", MatchAny): - COMPLETE_WITH("OWNER", "LOCATION"); + COMPLETE_WITH("OWNER", "LOCATION"); break; - /* Complete CREATE TABLESPACE name OWNER name with "LOCATION" */ + /* Complete CREATE TABLESPACE name OWNER name with "LOCATION" */ case Matches("CREATE", "TABLESPACE", MatchAny, "OWNER", MatchAny): - COMPLETE_WITH("LOCATION"); + COMPLETE_WITH("LOCATION"); break; /* CREATE TEXT SEARCH */ case Matches("CREATE", "TEXT", "SEARCH"): - COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); + COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); break; case Matches("CREATE", "TEXT", "SEARCH", "CONFIGURATION|DICTIONARY|PARSER|TEMPLATE", MatchAny): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; /* CREATE TRANSFORM */ case Matches("CREATE", "TRANSFORM"): case Matches("CREATE", "OR", "REPLACE", "TRANSFORM"): - COMPLETE_WITH("FOR"); + COMPLETE_WITH("FOR"); break; case Matches("CREATE", "TRANSFORM", "FOR"): case Matches("CREATE", "OR", "REPLACE", "TRANSFORM", "FOR"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case Matches("CREATE", "TRANSFORM", "FOR", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRANSFORM", "FOR", MatchAny): - COMPLETE_WITH("LANGUAGE"); + COMPLETE_WITH("LANGUAGE"); break; case Matches("CREATE", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"): case Matches("CREATE", "OR", "REPLACE", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_QUERY(Query_for_list_of_languages); + set_completion_reference(prev2_wd); + COMPLETE_WITH_QUERY(Query_for_list_of_languages); break; /* CREATE SUBSCRIPTION */ case Matches("CREATE", "SUBSCRIPTION", MatchAny): - COMPLETE_WITH("CONNECTION"); + COMPLETE_WITH("CONNECTION"); break; case Matches("CREATE", "SUBSCRIPTION", MatchAny, "CONNECTION", MatchAny): - COMPLETE_WITH("PUBLICATION"); + COMPLETE_WITH("PUBLICATION"); break; case Matches("CREATE", "SUBSCRIPTION", MatchAny, "CONNECTION", MatchAny, "PUBLICATION"): - /* complete with nothing here as this refers to remote publications */ + + /* + * complete with nothing here as this refers to remote + * publications + */ break; case Matches("CREATE", "SUBSCRIPTION", MatchAnyN, "PUBLICATION", MatchAny): - COMPLETE_WITH("WITH ("); + COMPLETE_WITH("WITH ("); break; - /* Complete "CREATE SUBSCRIPTION ... WITH ( " */ + /* Complete "CREATE SUBSCRIPTION ... WITH ( " */ case Matches("CREATE", "SUBSCRIPTION", MatchAnyN, "WITH", "("): - COMPLETE_WITH("binary", "connect", "copy_data", "create_slot", - "disable_on_error", "enabled", "failover", "origin", - "password_required", "run_as_owner", "slot_name", - "streaming", "synchronous_commit", "two_phase"); + COMPLETE_WITH("binary", "connect", "copy_data", "create_slot", + "disable_on_error", "enabled", "failover", "origin", + "password_required", "run_as_owner", "slot_name", + "streaming", "synchronous_commit", "two_phase"); break; /* CREATE TRIGGER --- is allowed inside CREATE SCHEMA, so use TailMatches */ - /* - * Complete CREATE [ OR REPLACE ] TRIGGER with BEFORE|AFTER|INSTEAD - * OF. - */ + /* + * Complete CREATE [ OR REPLACE ] TRIGGER with + * BEFORE|AFTER|INSTEAD OF. + */ case TailMatches("CREATE", "TRIGGER", MatchAny): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny): - COMPLETE_WITH("BEFORE", "AFTER", "INSTEAD OF"); + COMPLETE_WITH("BEFORE", "AFTER", "INSTEAD OF"); break; - /* - * Complete CREATE [ OR REPLACE ] TRIGGER BEFORE,AFTER with an - * event. - */ + /* + * Complete CREATE [ OR REPLACE ] TRIGGER BEFORE,AFTER with + * an event. + */ case TailMatches("CREATE", "TRIGGER", MatchAny, "BEFORE|AFTER"): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "BEFORE|AFTER"): - COMPLETE_WITH("INSERT", "DELETE", "UPDATE", "TRUNCATE"); + COMPLETE_WITH("INSERT", "DELETE", "UPDATE", "TRUNCATE"); break; - /* Complete CREATE [ OR REPLACE ] TRIGGER INSTEAD OF with an event */ + + /* + * Complete CREATE [ OR REPLACE ] TRIGGER INSTEAD OF with + * an event + */ case TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF"): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "INSTEAD", "OF"): - COMPLETE_WITH("INSERT", "DELETE", "UPDATE"); + COMPLETE_WITH("INSERT", "DELETE", "UPDATE"); break; - /* - * Complete CREATE [ OR REPLACE ] TRIGGER BEFORE,AFTER sth with - * OR|ON. - */ + /* + * Complete CREATE [ OR REPLACE ] TRIGGER BEFORE,AFTER sth + * with OR|ON. + */ case TailMatches("CREATE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny): case TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny): - COMPLETE_WITH("ON", "OR"); + COMPLETE_WITH("ON", "OR"); break; - /* - * Complete CREATE [ OR REPLACE ] TRIGGER BEFORE,AFTER event ON - * with a list of tables. EXECUTE FUNCTION is the recommended grammar - * instead of EXECUTE PROCEDURE in version 11 and upwards. - */ + /* + * Complete CREATE [ OR REPLACE ] TRIGGER BEFORE,AFTER + * event ON with a list of tables. EXECUTE FUNCTION is the + * recommended grammar instead of EXECUTE PROCEDURE in version 11 + * and upwards. + */ case TailMatches("CREATE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny, "ON"): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny, "ON"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* - * Complete CREATE [ OR REPLACE ] TRIGGER ... INSTEAD OF event ON with a - * list of views. - */ - case TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny, "ON"): + /* + * Complete CREATE [ OR REPLACE ] TRIGGER ... INSTEAD OF event ON + * with a list of views. + */ + case TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny, "ON"): case TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny, "ON"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "ON", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "ON", MatchAny): - if (pset.sversion >= 110000) - COMPLETE_WITH("NOT DEFERRABLE", "DEFERRABLE", "INITIALLY", - "REFERENCING", "FOR", "WHEN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("NOT DEFERRABLE", "DEFERRABLE", "INITIALLY", - "REFERENCING", "FOR", "WHEN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("NOT DEFERRABLE", "DEFERRABLE", "INITIALLY", + "REFERENCING", "FOR", "WHEN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("NOT DEFERRABLE", "DEFERRABLE", "INITIALLY", + "REFERENCING", "FOR", "WHEN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "DEFERRABLE"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "DEFERRABLE"): case Matches("CREATE", "TRIGGER", MatchAnyN, "INITIALLY", "IMMEDIATE|DEFERRED"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "INITIALLY", "IMMEDIATE|DEFERRED"): - if (pset.sversion >= 110000) - COMPLETE_WITH("REFERENCING", "FOR", "WHEN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("REFERENCING", "FOR", "WHEN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("REFERENCING", "FOR", "WHEN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("REFERENCING", "FOR", "WHEN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING"): - COMPLETE_WITH("OLD TABLE", "NEW TABLE"); + COMPLETE_WITH("OLD TABLE", "NEW TABLE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "OLD|NEW", "TABLE"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "OLD|NEW", "TABLE"): - COMPLETE_WITH("AS"); + COMPLETE_WITH("AS"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD", "TABLE", "AS", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD", "TABLE", "AS", MatchAny): case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD", "TABLE", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD", "TABLE", MatchAny): - if (pset.sversion >= 110000) - COMPLETE_WITH("NEW TABLE", "FOR", "WHEN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("NEW TABLE", "FOR", "WHEN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("NEW TABLE", "FOR", "WHEN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("NEW TABLE", "FOR", "WHEN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING", "NEW", "TABLE", "AS", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "NEW", "TABLE", "AS", MatchAny): case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING", "NEW", "TABLE", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "NEW", "TABLE", MatchAny): - if (pset.sversion >= 110000) - COMPLETE_WITH("OLD TABLE", "FOR", "WHEN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("OLD TABLE", "FOR", "WHEN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("OLD TABLE", "FOR", "WHEN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("OLD TABLE", "FOR", "WHEN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD|NEW", "TABLE", "AS", MatchAny, "OLD|NEW", "TABLE", "AS", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD|NEW", "TABLE", "AS", MatchAny, "OLD|NEW", "TABLE", "AS", MatchAny): @@ -4028,440 +4105,440 @@ match_previous_words(int pattern_id, case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD|NEW", "TABLE", "AS", MatchAny, "OLD|NEW", "TABLE", MatchAny): case Matches("CREATE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD|NEW", "TABLE", MatchAny, "OLD|NEW", "TABLE", MatchAny): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "REFERENCING", "OLD|NEW", "TABLE", MatchAny, "OLD|NEW", "TABLE", MatchAny): - if (pset.sversion >= 110000) - COMPLETE_WITH("FOR", "WHEN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("FOR", "WHEN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("FOR", "WHEN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("FOR", "WHEN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "FOR"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "FOR"): - COMPLETE_WITH("EACH", "ROW", "STATEMENT"); + COMPLETE_WITH("EACH", "ROW", "STATEMENT"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "FOR", "EACH"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "FOR", "EACH"): - COMPLETE_WITH("ROW", "STATEMENT"); + COMPLETE_WITH("ROW", "STATEMENT"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "FOR", "EACH", "ROW|STATEMENT"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "FOR", "EACH", "ROW|STATEMENT"): case Matches("CREATE", "TRIGGER", MatchAnyN, "FOR", "ROW|STATEMENT"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "FOR", "ROW|STATEMENT"): - if (pset.sversion >= 110000) - COMPLETE_WITH("WHEN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("WHEN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("WHEN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("WHEN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "WHEN", "(*)"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "WHEN", "(*)"): - if (pset.sversion >= 110000) - COMPLETE_WITH("EXECUTE FUNCTION"); - else - COMPLETE_WITH("EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("EXECUTE FUNCTION"); + else + COMPLETE_WITH("EXECUTE PROCEDURE"); break; - /* - * Complete CREATE [ OR REPLACE ] TRIGGER ... EXECUTE with - * PROCEDURE|FUNCTION. - */ + /* + * Complete CREATE [ OR REPLACE ] TRIGGER ... EXECUTE with + * PROCEDURE|FUNCTION. + */ case Matches("CREATE", "TRIGGER", MatchAnyN, "EXECUTE"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "EXECUTE"): - if (pset.sversion >= 110000) - COMPLETE_WITH("FUNCTION"); - else - COMPLETE_WITH("PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("FUNCTION"); + else + COMPLETE_WITH("PROCEDURE"); break; case Matches("CREATE", "TRIGGER", MatchAnyN, "EXECUTE", "FUNCTION|PROCEDURE"): case Matches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAnyN, "EXECUTE", "FUNCTION|PROCEDURE"): - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); break; /* CREATE ROLE,USER,GROUP */ case Matches("CREATE", "ROLE|GROUP|USER", MatchAny): - if (!TailMatches("USER", "MAPPING")) - COMPLETE_WITH("ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", - "CREATEROLE", "ENCRYPTED PASSWORD", "IN", "INHERIT", - "LOGIN", "NOBYPASSRLS", - "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", - "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", - "REPLICATION", "ROLE", "SUPERUSER", "SYSID", - "VALID UNTIL", "WITH"); + if (!TailMatches("USER", "MAPPING")) + COMPLETE_WITH("ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", + "CREATEROLE", "ENCRYPTED PASSWORD", "IN", "INHERIT", + "LOGIN", "NOBYPASSRLS", + "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", + "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", + "REPLICATION", "ROLE", "SUPERUSER", "SYSID", + "VALID UNTIL", "WITH"); break; /* CREATE ROLE,USER,GROUP WITH */ case Matches("CREATE", "ROLE|GROUP|USER", MatchAny, "WITH"): - /* Similar to the above, but don't complete "WITH" again. */ - COMPLETE_WITH("ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", - "CREATEROLE", "ENCRYPTED PASSWORD", "IN", "INHERIT", - "LOGIN", "NOBYPASSRLS", - "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", - "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", - "REPLICATION", "ROLE", "SUPERUSER", "SYSID", - "VALID UNTIL"); + /* Similar to the above, but don't complete "WITH" again. */ + COMPLETE_WITH("ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", + "CREATEROLE", "ENCRYPTED PASSWORD", "IN", "INHERIT", + "LOGIN", "NOBYPASSRLS", + "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", + "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD", + "REPLICATION", "ROLE", "SUPERUSER", "SYSID", + "VALID UNTIL"); break; - /* complete CREATE ROLE,USER,GROUP IN with ROLE,GROUP */ + /* complete CREATE ROLE,USER,GROUP IN with ROLE,GROUP */ case Matches("CREATE", "ROLE|USER|GROUP", MatchAny, "IN"): - COMPLETE_WITH("GROUP", "ROLE"); + COMPLETE_WITH("GROUP", "ROLE"); break; /* CREATE TYPE */ case Matches("CREATE", "TYPE", MatchAny): - COMPLETE_WITH("(", "AS"); + COMPLETE_WITH("(", "AS"); break; case Matches("CREATE", "TYPE", MatchAny, "AS"): - COMPLETE_WITH("ENUM", "RANGE", "("); + COMPLETE_WITH("ENUM", "RANGE", "("); break; case HeadMatches("CREATE", "TYPE", MatchAny, "AS", "("): - if (TailMatches("(|*,", MatchAny)) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); - else if (TailMatches("(|*,", MatchAny, MatchAnyExcept("*)"))) - COMPLETE_WITH("COLLATE", ",", ")"); + if (TailMatches("(|*,", MatchAny)) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + else if (TailMatches("(|*,", MatchAny, MatchAnyExcept("*)"))) + COMPLETE_WITH("COLLATE", ",", ")"); break; case Matches("CREATE", "TYPE", MatchAny, "AS", "ENUM|RANGE"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; case HeadMatches("CREATE", "TYPE", MatchAny, "("): - if (TailMatches("(|*,")) - COMPLETE_WITH("INPUT", "OUTPUT", "RECEIVE", "SEND", - "TYPMOD_IN", "TYPMOD_OUT", "ANALYZE", "SUBSCRIPT", - "INTERNALLENGTH", "PASSEDBYVALUE", "ALIGNMENT", - "STORAGE", "LIKE", "CATEGORY", "PREFERRED", - "DEFAULT", "ELEMENT", "DELIMITER", - "COLLATABLE"); - else if (TailMatches("(*|*,", MatchAnyExcept("*="))) - COMPLETE_WITH("="); - else if (TailMatches("=", MatchAnyExcept("*)"))) - COMPLETE_WITH(",", ")"); + if (TailMatches("(|*,")) + COMPLETE_WITH("INPUT", "OUTPUT", "RECEIVE", "SEND", + "TYPMOD_IN", "TYPMOD_OUT", "ANALYZE", "SUBSCRIPT", + "INTERNALLENGTH", "PASSEDBYVALUE", "ALIGNMENT", + "STORAGE", "LIKE", "CATEGORY", "PREFERRED", + "DEFAULT", "ELEMENT", "DELIMITER", + "COLLATABLE"); + else if (TailMatches("(*|*,", MatchAnyExcept("*="))) + COMPLETE_WITH("="); + else if (TailMatches("=", MatchAnyExcept("*)"))) + COMPLETE_WITH(",", ")"); break; case HeadMatches("CREATE", "TYPE", MatchAny, "AS", "RANGE", "("): - if (TailMatches("(|*,")) - COMPLETE_WITH("SUBTYPE", "SUBTYPE_OPCLASS", "COLLATION", - "CANONICAL", "SUBTYPE_DIFF", - "MULTIRANGE_TYPE_NAME"); - else if (TailMatches("(*|*,", MatchAnyExcept("*="))) - COMPLETE_WITH("="); - else if (TailMatches("=", MatchAnyExcept("*)"))) - COMPLETE_WITH(",", ")"); + if (TailMatches("(|*,")) + COMPLETE_WITH("SUBTYPE", "SUBTYPE_OPCLASS", "COLLATION", + "CANONICAL", "SUBTYPE_DIFF", + "MULTIRANGE_TYPE_NAME"); + else if (TailMatches("(*|*,", MatchAnyExcept("*="))) + COMPLETE_WITH("="); + else if (TailMatches("=", MatchAnyExcept("*)"))) + COMPLETE_WITH(",", ")"); break; /* CREATE VIEW --- is allowed inside CREATE SCHEMA, so use TailMatches */ - /* Complete CREATE [ OR REPLACE ] VIEW with AS or WITH */ + /* Complete CREATE [ OR REPLACE ] VIEW with AS or WITH */ case TailMatches("CREATE", "VIEW", MatchAny): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny): - COMPLETE_WITH("AS", "WITH"); + COMPLETE_WITH("AS", "WITH"); break; - /* Complete "CREATE [ OR REPLACE ] VIEW AS with "SELECT" */ + /* Complete "CREATE [ OR REPLACE ] VIEW AS with "SELECT" */ case TailMatches("CREATE", "VIEW", MatchAny, "AS"): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "AS"): - COMPLETE_WITH("SELECT"); + COMPLETE_WITH("SELECT"); break; - /* CREATE [ OR REPLACE ] VIEW WITH ( yyy [= zzz] ) */ + /* CREATE [ OR REPLACE ] VIEW WITH ( yyy [= zzz] ) */ case TailMatches("CREATE", "VIEW", MatchAny, "WITH"): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "WITH"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; case TailMatches("CREATE", "VIEW", MatchAny, "WITH", "("): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "WITH", "("): - COMPLETE_WITH_LIST(view_optional_parameters); + COMPLETE_WITH_LIST(view_optional_parameters); break; case TailMatches("CREATE", "VIEW", MatchAny, "WITH", "(", "check_option"): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "WITH", "(", "check_option"): - COMPLETE_WITH("="); + COMPLETE_WITH("="); break; case TailMatches("CREATE", "VIEW", MatchAny, "WITH", "(", "check_option", "="): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "WITH", "(", "check_option", "="): - COMPLETE_WITH("local", "cascaded"); + COMPLETE_WITH("local", "cascaded"); break; - /* CREATE [ OR REPLACE ] VIEW WITH ( ... ) AS */ + /* CREATE [ OR REPLACE ] VIEW WITH ( ... ) AS */ case TailMatches("CREATE", "VIEW", MatchAny, "WITH", "(*)"): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "WITH", "(*)"): - COMPLETE_WITH("AS"); + COMPLETE_WITH("AS"); break; - /* CREATE [ OR REPLACE ] VIEW WITH ( ... ) AS SELECT */ + /* CREATE [ OR REPLACE ] VIEW WITH ( ... ) AS SELECT */ case TailMatches("CREATE", "VIEW", MatchAny, "WITH", "(*)", "AS"): case TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "WITH", "(*)", "AS"): - COMPLETE_WITH("SELECT"); + COMPLETE_WITH("SELECT"); break; /* CREATE MATERIALIZED VIEW */ case Matches("CREATE", "MATERIALIZED"): - COMPLETE_WITH("VIEW"); + COMPLETE_WITH("VIEW"); break; - /* Complete CREATE MATERIALIZED VIEW with AS */ + /* Complete CREATE MATERIALIZED VIEW with AS */ case Matches("CREATE", "MATERIALIZED", "VIEW", MatchAny): - COMPLETE_WITH("AS"); + COMPLETE_WITH("AS"); break; - /* Complete "CREATE MATERIALIZED VIEW AS with "SELECT" */ + /* Complete "CREATE MATERIALIZED VIEW AS with "SELECT" */ case Matches("CREATE", "MATERIALIZED", "VIEW", MatchAny, "AS"): - COMPLETE_WITH("SELECT"); + COMPLETE_WITH("SELECT"); break; /* CREATE EVENT TRIGGER */ case Matches("CREATE", "EVENT"): - COMPLETE_WITH("TRIGGER"); + COMPLETE_WITH("TRIGGER"); break; - /* Complete CREATE EVENT TRIGGER with ON */ + /* Complete CREATE EVENT TRIGGER with ON */ case Matches("CREATE", "EVENT", "TRIGGER", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* Complete CREATE EVENT TRIGGER ON with event_type */ + /* Complete CREATE EVENT TRIGGER ON with event_type */ case Matches("CREATE", "EVENT", "TRIGGER", MatchAny, "ON"): - COMPLETE_WITH("ddl_command_start", "ddl_command_end", "login", - "sql_drop", "table_rewrite"); + COMPLETE_WITH("ddl_command_start", "ddl_command_end", "login", + "sql_drop", "table_rewrite"); break; - /* - * Complete CREATE EVENT TRIGGER ON . EXECUTE FUNCTION - * is the recommended grammar instead of EXECUTE PROCEDURE in version 11 - * and upwards. - */ + /* + * Complete CREATE EVENT TRIGGER ON . EXECUTE + * FUNCTION is the recommended grammar instead of EXECUTE + * PROCEDURE in version 11 and upwards. + */ case Matches("CREATE", "EVENT", "TRIGGER", MatchAny, "ON", MatchAny): - if (pset.sversion >= 110000) - COMPLETE_WITH("WHEN TAG IN (", "EXECUTE FUNCTION"); - else - COMPLETE_WITH("WHEN TAG IN (", "EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("WHEN TAG IN (", "EXECUTE FUNCTION"); + else + COMPLETE_WITH("WHEN TAG IN (", "EXECUTE PROCEDURE"); break; case Matches("CREATE", "EVENT", "TRIGGER", MatchAnyN, "WHEN|AND", MatchAny, "IN", "(*)"): - if (pset.sversion >= 110000) - COMPLETE_WITH("EXECUTE FUNCTION"); - else - COMPLETE_WITH("EXECUTE PROCEDURE"); + if (pset.sversion >= 110000) + COMPLETE_WITH("EXECUTE FUNCTION"); + else + COMPLETE_WITH("EXECUTE PROCEDURE"); break; case Matches("CREATE", "EVENT", "TRIGGER", MatchAnyN, "EXECUTE", "FUNCTION|PROCEDURE"): - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); break; /* DEALLOCATE */ case Matches("DEALLOCATE"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_prepared_statements, - "ALL"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_prepared_statements, + "ALL"); break; /* DECLARE */ - /* - * Complete DECLARE with one of BINARY, ASENSITIVE, INSENSITIVE, - * SCROLL, NO SCROLL, and CURSOR. - */ + /* + * Complete DECLARE with one of BINARY, ASENSITIVE, + * INSENSITIVE, SCROLL, NO SCROLL, and CURSOR. + */ case Matches("DECLARE", MatchAny): - COMPLETE_WITH("BINARY", "ASENSITIVE", "INSENSITIVE", "SCROLL", "NO SCROLL", - "CURSOR"); + COMPLETE_WITH("BINARY", "ASENSITIVE", "INSENSITIVE", "SCROLL", "NO SCROLL", + "CURSOR"); break; - /* - * Complete DECLARE ...
*/ + /* Complete DELETE FROM
*/ case TailMatches("DELETE", "FROM", MatchAny): - COMPLETE_WITH("USING", "WHERE"); + COMPLETE_WITH("USING", "WHERE"); break; - /* XXX: implement tab completion for DELETE ... USING */ + /* XXX: implement tab completion for DELETE ... USING */ /* DISCARD */ case Matches("DISCARD"): - COMPLETE_WITH("ALL", "PLANS", "SEQUENCES", "TEMP"); + COMPLETE_WITH("ALL", "PLANS", "SEQUENCES", "TEMP"); break; /* DO */ case Matches("DO"): - COMPLETE_WITH("LANGUAGE"); + COMPLETE_WITH("LANGUAGE"); break; /* DROP */ - /* Complete DROP object with CASCADE / RESTRICT */ + /* Complete DROP object with CASCADE / RESTRICT */ case Matches("DROP", "COLLATION|CONVERSION|DOMAIN|EXTENSION|LANGUAGE|PUBLICATION|SCHEMA|SEQUENCE|SERVER|SUBSCRIPTION|STATISTICS|TABLE|TYPE|VIEW", MatchAny): case Matches("DROP", "ACCESS", "METHOD", MatchAny): case Matches("DROP", "EVENT", "TRIGGER", MatchAny): case Matches("DROP", "FOREIGN", "DATA", "WRAPPER", MatchAny): case Matches("DROP", "FOREIGN", "TABLE", MatchAny): case Matches("DROP", "TEXT", "SEARCH", "CONFIGURATION|DICTIONARY|PARSER|TEMPLATE", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; case Matches("DROP", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny): - if (ends_with(prev_wd, ')')) - COMPLETE_WITH("CASCADE", "RESTRICT"); + if (ends_with(prev_wd, ')')) + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* help completing some of the variants */ + /* help completing some of the variants */ case Matches("DROP", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; case Matches("DROP", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny, "("): - COMPLETE_WITH_FUNCTION_ARG(prev2_wd); + COMPLETE_WITH_FUNCTION_ARG(prev2_wd); break; case Matches("DROP", "FOREIGN"): - COMPLETE_WITH("DATA WRAPPER", "TABLE"); + COMPLETE_WITH("DATA WRAPPER", "TABLE"); break; case Matches("DROP", "DATABASE", MatchAny): - COMPLETE_WITH("WITH ("); + COMPLETE_WITH("WITH ("); break; case HeadMatches("DROP", "DATABASE"): - if ((ends_with(prev_wd, '('))) - COMPLETE_WITH("FORCE"); + if ((ends_with(prev_wd, '('))) + COMPLETE_WITH("FORCE"); break; - /* DROP INDEX */ + /* DROP INDEX */ case Matches("DROP", "INDEX"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, - "CONCURRENTLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, + "CONCURRENTLY"); break; case Matches("DROP", "INDEX", "CONCURRENTLY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); break; case Matches("DROP", "INDEX", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; case Matches("DROP", "INDEX", "CONCURRENTLY", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* DROP MATERIALIZED VIEW */ + /* DROP MATERIALIZED VIEW */ case Matches("DROP", "MATERIALIZED"): - COMPLETE_WITH("VIEW"); + COMPLETE_WITH("VIEW"); break; case Matches("DROP", "MATERIALIZED", "VIEW"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); break; case Matches("DROP", "MATERIALIZED", "VIEW", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* DROP OWNED BY */ + /* DROP OWNED BY */ case Matches("DROP", "OWNED"): - COMPLETE_WITH("BY"); + COMPLETE_WITH("BY"); break; case Matches("DROP", "OWNED", "BY"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; case Matches("DROP", "OWNED", "BY", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* DROP TEXT SEARCH */ + /* DROP TEXT SEARCH */ case Matches("DROP", "TEXT", "SEARCH"): - COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); + COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); break; - /* DROP TRIGGER */ + /* DROP TRIGGER */ case Matches("DROP", "TRIGGER", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("DROP", "TRIGGER", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger); break; case Matches("DROP", "TRIGGER", MatchAny, "ON", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* DROP ACCESS METHOD */ + /* DROP ACCESS METHOD */ case Matches("DROP", "ACCESS"): - COMPLETE_WITH("METHOD"); + COMPLETE_WITH("METHOD"); break; case Matches("DROP", "ACCESS", "METHOD"): - COMPLETE_WITH_QUERY(Query_for_list_of_access_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_access_methods); break; - /* DROP EVENT TRIGGER */ + /* DROP EVENT TRIGGER */ case Matches("DROP", "EVENT"): - COMPLETE_WITH("TRIGGER"); + COMPLETE_WITH("TRIGGER"); break; case Matches("DROP", "EVENT", "TRIGGER"): - COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); + COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); break; - /* DROP POLICY */ + /* DROP POLICY */ case Matches("DROP", "POLICY"): - COMPLETE_WITH_QUERY(Query_for_list_of_policies); + COMPLETE_WITH_QUERY(Query_for_list_of_policies); break; - /* DROP POLICY ON */ + /* DROP POLICY ON */ case Matches("DROP", "POLICY", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* DROP POLICY ON
*/ + /* DROP POLICY ON
*/ case Matches("DROP", "POLICY", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy); break; case Matches("DROP", "POLICY", MatchAny, "ON", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* DROP RULE */ + /* DROP RULE */ case Matches("DROP", "RULE", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("DROP", "RULE", MatchAny, "ON"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule); + set_completion_reference(prev2_wd); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule); break; case Matches("DROP", "RULE", MatchAny, "ON", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; - /* DROP TRANSFORM */ + /* DROP TRANSFORM */ case Matches("DROP", "TRANSFORM"): - COMPLETE_WITH("FOR"); + COMPLETE_WITH("FOR"); break; case Matches("DROP", "TRANSFORM", "FOR"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case Matches("DROP", "TRANSFORM", "FOR", MatchAny): - COMPLETE_WITH("LANGUAGE"); + COMPLETE_WITH("LANGUAGE"); break; case Matches("DROP", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"): - set_completion_reference(prev2_wd); - COMPLETE_WITH_QUERY(Query_for_list_of_languages); + set_completion_reference(prev2_wd); + COMPLETE_WITH_QUERY(Query_for_list_of_languages); break; case Matches("DROP", "TRANSFORM", "FOR", MatchAny, "LANGUAGE", MatchAny): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; /* EXECUTE */ case Matches("EXECUTE"): - COMPLETE_WITH_QUERY(Query_for_list_of_prepared_statements); + COMPLETE_WITH_QUERY(Query_for_list_of_prepared_statements); break; /* @@ -4469,532 +4546,553 @@ match_previous_words(int pattern_id, * EXPLAIN [ ANALYZE ] [ VERBOSE ] statement */ case Matches("EXPLAIN"): - COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE", - "MERGE INTO", "EXECUTE", "ANALYZE", "VERBOSE"); + COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE", + "MERGE INTO", "EXECUTE", "ANALYZE", "VERBOSE"); break; case HeadMatches("EXPLAIN", "(*"): - if (!HeadMatches("EXPLAIN", "(*)")) - { - /* - * This fires if we're in an unfinished parenthesized option list. - * get_previous_words treats a completed parenthesized option list as - * one word, so the above test is correct. - */ - if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) - COMPLETE_WITH("ANALYZE", "VERBOSE", "COSTS", "SETTINGS", "GENERIC_PLAN", - "BUFFERS", "SERIALIZE", "WAL", "TIMING", "SUMMARY", - "MEMORY", "FORMAT"); - else if (TailMatches("ANALYZE|VERBOSE|COSTS|SETTINGS|GENERIC_PLAN|BUFFERS|WAL|TIMING|SUMMARY|MEMORY")) - COMPLETE_WITH("ON", "OFF"); - else if (TailMatches("SERIALIZE")) - COMPLETE_WITH("TEXT", "NONE", "BINARY"); - else if (TailMatches("FORMAT")) - COMPLETE_WITH("TEXT", "XML", "JSON", "YAML"); - } + if (!HeadMatches("EXPLAIN", "(*)")) + { + /* + * This fires if we're in an unfinished parenthesized option + * list. get_previous_words treats a completed parenthesized + * option list as one word, so the above test is correct. + */ + if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) + COMPLETE_WITH("ANALYZE", "VERBOSE", "COSTS", "SETTINGS", "GENERIC_PLAN", + "BUFFERS", "SERIALIZE", "WAL", "TIMING", "SUMMARY", + "MEMORY", "FORMAT"); + else if (TailMatches("ANALYZE|VERBOSE|COSTS|SETTINGS|GENERIC_PLAN|BUFFERS|WAL|TIMING|SUMMARY|MEMORY")) + COMPLETE_WITH("ON", "OFF"); + else if (TailMatches("SERIALIZE")) + COMPLETE_WITH("TEXT", "NONE", "BINARY"); + else if (TailMatches("FORMAT")) + COMPLETE_WITH("TEXT", "XML", "JSON", "YAML"); + } break; case Matches("EXPLAIN", "ANALYZE"): - COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE", - "MERGE INTO", "EXECUTE", "VERBOSE"); + COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE", + "MERGE INTO", "EXECUTE", "VERBOSE"); break; case Matches("EXPLAIN", "(*)"): case Matches("EXPLAIN", "VERBOSE"): case Matches("EXPLAIN", "ANALYZE", "VERBOSE"): - COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE", - "MERGE INTO", "EXECUTE"); + COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE", + "MERGE INTO", "EXECUTE"); break; /* FETCH && MOVE */ - /* - * Complete FETCH with one of ABSOLUTE, BACKWARD, FORWARD, RELATIVE, ALL, - * NEXT, PRIOR, FIRST, LAST, FROM, IN, and a list of cursors - */ + /* + * Complete FETCH with one of ABSOLUTE, BACKWARD, FORWARD, + * RELATIVE, ALL, NEXT, PRIOR, FIRST, LAST, FROM, IN, and a list + * of cursors + */ case Matches("FETCH|MOVE"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, - "ABSOLUTE", - "BACKWARD", - "FORWARD", - "RELATIVE", - "ALL", - "NEXT", - "PRIOR", - "FIRST", - "LAST", - "FROM", - "IN"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, + "ABSOLUTE", + "BACKWARD", + "FORWARD", + "RELATIVE", + "ALL", + "NEXT", + "PRIOR", + "FIRST", + "LAST", + "FROM", + "IN"); break; - /* - * Complete FETCH BACKWARD or FORWARD with one of ALL, FROM, IN, and a - * list of cursors - */ + /* + * Complete FETCH BACKWARD or FORWARD with one of ALL, FROM, IN, + * and a list of cursors + */ case Matches("FETCH|MOVE", "BACKWARD|FORWARD"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, - "ALL", - "FROM", - "IN"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, + "ALL", + "FROM", + "IN"); break; - /* - * Complete FETCH with "FROM" or "IN". These are equivalent, - * but we may as well tab-complete both: perhaps some users prefer one - * variant or the other. - */ + /* + * Complete FETCH with "FROM" or "IN". These are + * equivalent, but we may as well tab-complete both: perhaps some + * users prefer one variant or the other. + */ case Matches("FETCH|MOVE", "ABSOLUTE|BACKWARD|FORWARD|RELATIVE", MatchAnyExcept("FROM|IN")): case Matches("FETCH|MOVE", "ALL|NEXT|PRIOR|FIRST|LAST"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, - "FROM", - "IN"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors, + "FROM", + "IN"); break; - /* Complete FETCH "FROM" or "IN" with a list of cursors */ + + /* + * Complete FETCH "FROM" or "IN" with a list of + * cursors + */ case Matches("FETCH|MOVE", MatchAnyN, "FROM|IN"): - COMPLETE_WITH_QUERY(Query_for_list_of_cursors); + COMPLETE_WITH_QUERY(Query_for_list_of_cursors); break; /* FOREIGN DATA WRAPPER */ - /* applies in ALTER/DROP FDW and in CREATE SERVER */ + /* applies in ALTER/DROP FDW and in CREATE SERVER */ case TailMatches("FOREIGN", "DATA", "WRAPPER"): - if (!TailMatches("CREATE", MatchAny, MatchAny, MatchAny)) - COMPLETE_WITH_QUERY(Query_for_list_of_fdws); + if (!TailMatches("CREATE", MatchAny, MatchAny, MatchAny)) + COMPLETE_WITH_QUERY(Query_for_list_of_fdws); break; - /* applies in CREATE SERVER */ + /* applies in CREATE SERVER */ case Matches("CREATE", "SERVER", MatchAnyN, "FOREIGN", "DATA", "WRAPPER", MatchAny): - COMPLETE_WITH("OPTIONS"); + COMPLETE_WITH("OPTIONS"); break; /* FOREIGN TABLE */ case TailMatches("FOREIGN", "TABLE"): - if (!TailMatches("CREATE", MatchAny, MatchAny)) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables); + if (!TailMatches("CREATE", MatchAny, MatchAny)) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables); break; /* FOREIGN SERVER */ case TailMatches("FOREIGN", "SERVER"): - COMPLETE_WITH_QUERY(Query_for_list_of_servers); + COMPLETE_WITH_QUERY(Query_for_list_of_servers); break; /* * GRANT and REVOKE are allowed inside CREATE SCHEMA and * ALTER DEFAULT PRIVILEGES, so use TailMatches */ - /* Complete GRANT/REVOKE with a list of roles and privileges */ + /* Complete GRANT/REVOKE with a list of roles and privileges */ case TailMatches("GRANT|REVOKE"): case TailMatches("REVOKE", "ADMIN|GRANT|INHERIT|SET", "OPTION", "FOR"): - /* - * With ALTER DEFAULT PRIVILEGES, restrict completion to grantable - * privileges (can't grant roles) - */ - if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES")) - { - if (TailMatches("GRANT") || - TailMatches("REVOKE", "GRANT", "OPTION", "FOR")) - COMPLETE_WITH("SELECT", "INSERT", "UPDATE", - "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", - "CREATE", "EXECUTE", "USAGE", "MAINTAIN", "ALL"); + + /* + * With ALTER DEFAULT PRIVILEGES, restrict completion to grantable + * privileges (can't grant roles) + */ + if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES")) + { + if (TailMatches("GRANT") || + TailMatches("REVOKE", "GRANT", "OPTION", "FOR")) + COMPLETE_WITH("SELECT", "INSERT", "UPDATE", + "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", + "CREATE", "EXECUTE", "USAGE", "MAINTAIN", "ALL"); + else if (TailMatches("REVOKE")) + COMPLETE_WITH("SELECT", "INSERT", "UPDATE", + "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", + "CREATE", "EXECUTE", "USAGE", "MAINTAIN", "ALL", + "GRANT OPTION FOR"); + } + else if (TailMatches("GRANT")) + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Privilege_options_of_grant_and_revoke); else if (TailMatches("REVOKE")) - COMPLETE_WITH("SELECT", "INSERT", "UPDATE", - "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", - "CREATE", "EXECUTE", "USAGE", "MAINTAIN", "ALL", - "GRANT OPTION FOR"); - } - else if (TailMatches("GRANT")) - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Privilege_options_of_grant_and_revoke); - else if (TailMatches("REVOKE")) - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Privilege_options_of_grant_and_revoke, - "GRANT OPTION FOR", - "ADMIN OPTION FOR", - "INHERIT OPTION FOR", - "SET OPTION FOR"); - else if (TailMatches("REVOKE", "GRANT", "OPTION", "FOR")) - COMPLETE_WITH(Privilege_options_of_grant_and_revoke); - else if (TailMatches("REVOKE", "ADMIN|INHERIT|SET", "OPTION", "FOR")) - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Privilege_options_of_grant_and_revoke, + "GRANT OPTION FOR", + "ADMIN OPTION FOR", + "INHERIT OPTION FOR", + "SET OPTION FOR"); + else if (TailMatches("REVOKE", "GRANT", "OPTION", "FOR")) + COMPLETE_WITH(Privilege_options_of_grant_and_revoke); + else if (TailMatches("REVOKE", "ADMIN|INHERIT|SET", "OPTION", "FOR")) + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; case TailMatches("GRANT|REVOKE", "ALTER"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", "ALTER"): - COMPLETE_WITH("SYSTEM"); + COMPLETE_WITH("SYSTEM"); break; case TailMatches("REVOKE", "SET"): - COMPLETE_WITH("ON PARAMETER", "OPTION FOR"); + COMPLETE_WITH("ON PARAMETER", "OPTION FOR"); break; case TailMatches("GRANT", "SET"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", "SET"): case TailMatches("GRANT|REVOKE", "ALTER", "SYSTEM"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", "ALTER", "SYSTEM"): - COMPLETE_WITH("ON PARAMETER"); + COMPLETE_WITH("ON PARAMETER"); break; case TailMatches("GRANT|REVOKE", MatchAny, "ON", "PARAMETER"): case TailMatches("GRANT|REVOKE", MatchAny, MatchAny, "ON", "PARAMETER"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "PARAMETER"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, MatchAny, "ON", "PARAMETER"): - COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_alter_system_set_vars); + COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_alter_system_set_vars); break; case TailMatches("GRANT", MatchAny, "ON", "PARAMETER", MatchAny): case TailMatches("GRANT", MatchAny, MatchAny, "ON", "PARAMETER", MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; case TailMatches("REVOKE", MatchAny, "ON", "PARAMETER", MatchAny): case TailMatches("REVOKE", MatchAny, MatchAny, "ON", "PARAMETER", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "PARAMETER", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, MatchAny, "ON", "PARAMETER", MatchAny): - COMPLETE_WITH("FROM"); + COMPLETE_WITH("FROM"); break; - /* - * Complete GRANT/REVOKE with "ON", GRANT/REVOKE with - * TO/FROM - */ + /* + * Complete GRANT/REVOKE with "ON", GRANT/REVOKE + * with TO/FROM + */ case TailMatches("GRANT|REVOKE", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny): - if (TailMatches("SELECT|INSERT|UPDATE|DELETE|TRUNCATE|REFERENCES|TRIGGER|CREATE|CONNECT|TEMPORARY|TEMP|EXECUTE|USAGE|MAINTAIN|ALL")) - COMPLETE_WITH("ON"); - else if (TailMatches("GRANT", MatchAny)) - COMPLETE_WITH("TO"); - else - COMPLETE_WITH("FROM"); + if (TailMatches("SELECT|INSERT|UPDATE|DELETE|TRUNCATE|REFERENCES|TRIGGER|CREATE|CONNECT|TEMPORARY|TEMP|EXECUTE|USAGE|MAINTAIN|ALL")) + COMPLETE_WITH("ON"); + else if (TailMatches("GRANT", MatchAny)) + COMPLETE_WITH("TO"); + else + COMPLETE_WITH("FROM"); break; - /* - * Complete GRANT/REVOKE ON with a list of appropriate relations. - * - * Note: GRANT/REVOKE can get quite complex; tab-completion as implemented - * here will only work if the privilege list contains exactly one - * privilege. - */ + /* + * Complete GRANT/REVOKE ON with a list of appropriate + * relations. + * + * Note: GRANT/REVOKE can get quite complex; tab-completion as + * implemented here will only work if the privilege list contains + * exactly one privilege. + */ case TailMatches("GRANT|REVOKE", MatchAny, "ON"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON"): - /* - * With ALTER DEFAULT PRIVILEGES, restrict completion to the kinds of - * objects supported. - */ - if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES")) - COMPLETE_WITH("TABLES", "SEQUENCES", "FUNCTIONS", "PROCEDURES", "ROUTINES", "TYPES", "SCHEMAS"); - else - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_grantables, - "ALL FUNCTIONS IN SCHEMA", - "ALL PROCEDURES IN SCHEMA", - "ALL ROUTINES IN SCHEMA", - "ALL SEQUENCES IN SCHEMA", - "ALL TABLES IN SCHEMA", - "DATABASE", - "DOMAIN", - "FOREIGN DATA WRAPPER", - "FOREIGN SERVER", - "FUNCTION", - "LANGUAGE", - "LARGE OBJECT", - "PARAMETER", - "PROCEDURE", - "ROUTINE", - "SCHEMA", - "SEQUENCE", - "TABLE", - "TABLESPACE", - "TYPE"); + + /* + * With ALTER DEFAULT PRIVILEGES, restrict completion to the kinds + * of objects supported. + */ + if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES")) + COMPLETE_WITH("TABLES", "SEQUENCES", "FUNCTIONS", "PROCEDURES", "ROUTINES", "TYPES", "SCHEMAS"); + else + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_grantables, + "ALL FUNCTIONS IN SCHEMA", + "ALL PROCEDURES IN SCHEMA", + "ALL ROUTINES IN SCHEMA", + "ALL SEQUENCES IN SCHEMA", + "ALL TABLES IN SCHEMA", + "DATABASE", + "DOMAIN", + "FOREIGN DATA WRAPPER", + "FOREIGN SERVER", + "FUNCTION", + "LANGUAGE", + "LARGE OBJECT", + "PARAMETER", + "PROCEDURE", + "ROUTINE", + "SCHEMA", + "SEQUENCE", + "TABLE", + "TABLESPACE", + "TYPE"); break; case TailMatches("GRANT|REVOKE", MatchAny, "ON", "ALL"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "ALL"): - COMPLETE_WITH("FUNCTIONS IN SCHEMA", - "PROCEDURES IN SCHEMA", - "ROUTINES IN SCHEMA", - "SEQUENCES IN SCHEMA", - "TABLES IN SCHEMA"); + COMPLETE_WITH("FUNCTIONS IN SCHEMA", + "PROCEDURES IN SCHEMA", + "ROUTINES IN SCHEMA", + "SEQUENCES IN SCHEMA", + "TABLES IN SCHEMA"); break; case TailMatches("GRANT|REVOKE", MatchAny, "ON", "FOREIGN"): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "FOREIGN"): - COMPLETE_WITH("DATA WRAPPER", "SERVER"); + COMPLETE_WITH("DATA WRAPPER", "SERVER"); break; - /* - * Complete "GRANT/REVOKE * ON DATABASE/DOMAIN/..." with a list of - * appropriate objects. - * - * Complete "GRANT/REVOKE * ON *" with "TO/FROM". - */ + /* + * Complete "GRANT/REVOKE * ON DATABASE/DOMAIN/..." with a list of + * appropriate objects. + * + * Complete "GRANT/REVOKE * ON *" with "TO/FROM". + */ case TailMatches("GRANT|REVOKE", MatchAny, "ON", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", MatchAny): - if (TailMatches("DATABASE")) - COMPLETE_WITH_QUERY(Query_for_list_of_databases); - else if (TailMatches("DOMAIN")) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains); - else if (TailMatches("FUNCTION")) - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); - else if (TailMatches("LANGUAGE")) - COMPLETE_WITH_QUERY(Query_for_list_of_languages); - else if (TailMatches("PROCEDURE")) - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures); - else if (TailMatches("ROUTINE")) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines); - else if (TailMatches("SCHEMA")) - COMPLETE_WITH_QUERY(Query_for_list_of_schemas); - else if (TailMatches("SEQUENCE")) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences); - else if (TailMatches("TABLE")) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_grantables); - else if (TailMatches("TABLESPACE")) - COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); - else if (TailMatches("TYPE")) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); - else if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny)) - COMPLETE_WITH("TO"); - else - COMPLETE_WITH("FROM"); + if (TailMatches("DATABASE")) + COMPLETE_WITH_QUERY(Query_for_list_of_databases); + else if (TailMatches("DOMAIN")) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains); + else if (TailMatches("FUNCTION")) + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); + else if (TailMatches("LANGUAGE")) + COMPLETE_WITH_QUERY(Query_for_list_of_languages); + else if (TailMatches("PROCEDURE")) + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures); + else if (TailMatches("ROUTINE")) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines); + else if (TailMatches("SCHEMA")) + COMPLETE_WITH_QUERY(Query_for_list_of_schemas); + else if (TailMatches("SEQUENCE")) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences); + else if (TailMatches("TABLE")) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_grantables); + else if (TailMatches("TABLESPACE")) + COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); + else if (TailMatches("TYPE")) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + else if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny)) + COMPLETE_WITH("TO"); + else + COMPLETE_WITH("FROM"); break; - /* - * Complete "GRANT/REVOKE ... TO/FROM" with username, PUBLIC, - * CURRENT_ROLE, CURRENT_USER, or SESSION_USER. - */ + /* + * Complete "GRANT/REVOKE ... TO/FROM" with username, PUBLIC, + * CURRENT_ROLE, CURRENT_USER, or SESSION_USER. + */ case Matches("GRANT", MatchAnyN, "TO"): case Matches("REVOKE", MatchAnyN, "FROM"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_grant_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_grant_roles); break; - /* - * Offer grant options after that. - */ + /* + * Offer grant options after that. + */ case Matches("GRANT", MatchAnyN, "TO", MatchAny): - COMPLETE_WITH("WITH ADMIN", - "WITH INHERIT", - "WITH SET", - "WITH GRANT OPTION", - "GRANTED BY"); + COMPLETE_WITH("WITH ADMIN", + "WITH INHERIT", + "WITH SET", + "WITH GRANT OPTION", + "GRANTED BY"); break; case Matches("GRANT", MatchAnyN, "TO", MatchAny, "WITH"): - COMPLETE_WITH("ADMIN", - "INHERIT", - "SET", - "GRANT OPTION"); + COMPLETE_WITH("ADMIN", + "INHERIT", + "SET", + "GRANT OPTION"); break; case Matches("GRANT", MatchAnyN, "TO", MatchAny, "WITH", "ADMIN|INHERIT|SET"): - COMPLETE_WITH("OPTION", "TRUE", "FALSE"); + COMPLETE_WITH("OPTION", "TRUE", "FALSE"); break; case Matches("GRANT", MatchAnyN, "TO", MatchAny, "WITH", MatchAny, "OPTION"): - COMPLETE_WITH("GRANTED BY"); + COMPLETE_WITH("GRANTED BY"); break; case Matches("GRANT", MatchAnyN, "TO", MatchAny, "WITH", MatchAny, "OPTION", "GRANTED", "BY"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_grant_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_grant_roles); break; - /* Complete "ALTER DEFAULT PRIVILEGES ... GRANT/REVOKE ... TO/FROM */ + /* Complete "ALTER DEFAULT PRIVILEGES ... GRANT/REVOKE ... TO/FROM */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", MatchAnyN, "TO|FROM"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_grant_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_grant_roles); break; - /* Offer WITH GRANT OPTION after that */ + /* Offer WITH GRANT OPTION after that */ case Matches("ALTER", "DEFAULT", "PRIVILEGES", MatchAnyN, "TO", MatchAny): - COMPLETE_WITH("WITH GRANT OPTION"); + COMPLETE_WITH("WITH GRANT OPTION"); break; - /* Complete "GRANT/REVOKE ... ON * *" with TO/FROM */ + /* Complete "GRANT/REVOKE ... ON * *" with TO/FROM */ case Matches("GRANT", MatchAnyN, "ON", MatchAny, MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; case Matches("REVOKE", MatchAnyN, "ON", MatchAny, MatchAny): - COMPLETE_WITH("FROM"); + COMPLETE_WITH("FROM"); break; - /* Complete "GRANT/REVOKE * ON ALL * IN SCHEMA *" with TO/FROM */ + /* Complete "GRANT/REVOKE * ON ALL * IN SCHEMA *" with TO/FROM */ case TailMatches("GRANT|REVOKE", MatchAny, "ON", "ALL", MatchAny, "IN", "SCHEMA", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "ALL", MatchAny, "IN", "SCHEMA", MatchAny): - if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny)) - COMPLETE_WITH("TO"); - else - COMPLETE_WITH("FROM"); + if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny)) + COMPLETE_WITH("TO"); + else + COMPLETE_WITH("FROM"); break; - /* Complete "GRANT/REVOKE * ON FOREIGN DATA WRAPPER *" with TO/FROM */ + /* + * Complete "GRANT/REVOKE * ON FOREIGN DATA WRAPPER *" with + * TO/FROM + */ case TailMatches("GRANT|REVOKE", MatchAny, "ON", "FOREIGN", "DATA", "WRAPPER", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "FOREIGN", "DATA", "WRAPPER", MatchAny): - if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny)) - COMPLETE_WITH("TO"); - else - COMPLETE_WITH("FROM"); + if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny)) + COMPLETE_WITH("TO"); + else + COMPLETE_WITH("FROM"); break; - /* Complete "GRANT/REVOKE * ON FOREIGN SERVER *" with TO/FROM */ + /* Complete "GRANT/REVOKE * ON FOREIGN SERVER *" with TO/FROM */ case TailMatches("GRANT|REVOKE", MatchAny, "ON", "FOREIGN", "SERVER", MatchAny): case TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "FOREIGN", "SERVER", MatchAny): - if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny)) - COMPLETE_WITH("TO"); - else - COMPLETE_WITH("FROM"); + if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny)) + COMPLETE_WITH("TO"); + else + COMPLETE_WITH("FROM"); break; /* GROUP BY */ case TailMatches("FROM", MatchAny, "GROUP"): - COMPLETE_WITH("BY"); + COMPLETE_WITH("BY"); break; /* IMPORT FOREIGN SCHEMA */ case Matches("IMPORT"): - COMPLETE_WITH("FOREIGN SCHEMA"); + COMPLETE_WITH("FOREIGN SCHEMA"); break; case Matches("IMPORT", "FOREIGN"): - COMPLETE_WITH("SCHEMA"); + COMPLETE_WITH("SCHEMA"); break; case Matches("IMPORT", "FOREIGN", "SCHEMA", MatchAny): - COMPLETE_WITH("EXCEPT (", "FROM SERVER", "LIMIT TO ("); + COMPLETE_WITH("EXCEPT (", "FROM SERVER", "LIMIT TO ("); break; case TailMatches("LIMIT", "TO", "(*)"): case TailMatches("EXCEPT", "(*)"): - COMPLETE_WITH("FROM SERVER"); + COMPLETE_WITH("FROM SERVER"); break; case TailMatches("FROM", "SERVER", MatchAny): - COMPLETE_WITH("INTO"); + COMPLETE_WITH("INTO"); break; case TailMatches("FROM", "SERVER", MatchAny, "INTO"): - COMPLETE_WITH_QUERY(Query_for_list_of_schemas); + COMPLETE_WITH_QUERY(Query_for_list_of_schemas); break; case TailMatches("FROM", "SERVER", MatchAny, "INTO", MatchAny): - COMPLETE_WITH("OPTIONS ("); + COMPLETE_WITH("OPTIONS ("); break; /* INSERT --- can be inside EXPLAIN, RULE, etc */ - /* Complete NOT MATCHED THEN INSERT */ + /* Complete NOT MATCHED THEN INSERT */ case TailMatches("NOT", "MATCHED", "THEN", "INSERT"): - COMPLETE_WITH("VALUES", "("); + COMPLETE_WITH("VALUES", "("); break; - /* Complete INSERT with "INTO" */ + /* Complete INSERT with "INTO" */ case TailMatches("INSERT"): - COMPLETE_WITH("INTO"); + COMPLETE_WITH("INTO"); break; - /* Complete INSERT INTO with table names */ + /* Complete INSERT INTO with table names */ case TailMatches("INSERT", "INTO"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables); break; - /* Complete "INSERT INTO
(" with attribute names */ + /* Complete "INSERT INTO
(" with attribute names */ case TailMatches("INSERT", "INTO", MatchAny, "("): - COMPLETE_WITH_ATTR(prev2_wd); + COMPLETE_WITH_ATTR(prev2_wd); break; - /* - * Complete INSERT INTO
with "(" or "VALUES" or "SELECT" or - * "TABLE" or "DEFAULT VALUES" or "OVERRIDING" - */ + /* + * Complete INSERT INTO
with "(" or "VALUES" or "SELECT" + * or "TABLE" or "DEFAULT VALUES" or "OVERRIDING" + */ case TailMatches("INSERT", "INTO", MatchAny): - COMPLETE_WITH("(", "DEFAULT VALUES", "SELECT", "TABLE", "VALUES", "OVERRIDING"); + COMPLETE_WITH("(", "DEFAULT VALUES", "SELECT", "TABLE", "VALUES", "OVERRIDING"); break; - /* - * Complete INSERT INTO
(attribs) with "VALUES" or "SELECT" or - * "TABLE" or "OVERRIDING" - */ + /* + * Complete INSERT INTO
(attribs) with "VALUES" or + * "SELECT" or "TABLE" or "OVERRIDING" + */ case TailMatches("INSERT", "INTO", MatchAny, MatchAny): - if (ends_with(prev_wd, ')')) - COMPLETE_WITH("SELECT", "TABLE", "VALUES", "OVERRIDING"); + if (ends_with(prev_wd, ')')) + COMPLETE_WITH("SELECT", "TABLE", "VALUES", "OVERRIDING"); break; - /* Complete OVERRIDING */ + /* Complete OVERRIDING */ case TailMatches("OVERRIDING"): - COMPLETE_WITH("SYSTEM VALUE", "USER VALUE"); + COMPLETE_WITH("SYSTEM VALUE", "USER VALUE"); break; - /* Complete after OVERRIDING clause */ + /* Complete after OVERRIDING clause */ case TailMatches("OVERRIDING", MatchAny, "VALUE"): - COMPLETE_WITH("SELECT", "TABLE", "VALUES"); + COMPLETE_WITH("SELECT", "TABLE", "VALUES"); break; - /* Insert an open parenthesis after "VALUES" */ + /* Insert an open parenthesis after "VALUES" */ case TailMatches("VALUES"): - if (!TailMatches("DEFAULT", "VALUES")) - COMPLETE_WITH("("); + if (!TailMatches("DEFAULT", "VALUES")) + COMPLETE_WITH("("); break; /* LOCK */ - /* Complete LOCK [TABLE] [ONLY] with a list of tables */ + /* Complete LOCK [TABLE] [ONLY] with a list of tables */ case Matches("LOCK"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, - "TABLE", "ONLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, + "TABLE", "ONLY"); break; case Matches("LOCK", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, - "ONLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, + "ONLY"); break; case Matches("LOCK", "TABLE", "ONLY"): case Matches("LOCK", "ONLY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; - /* For the following, handle the case of a single table only for now */ - /* Complete LOCK [TABLE] [ONLY]
with IN or NOWAIT */ + /* + * For the following, handle the case of a single table only for + * now + */ + + /* Complete LOCK [TABLE] [ONLY]
with IN or NOWAIT */ case Matches("LOCK", MatchAnyExcept("TABLE|ONLY")): case Matches("LOCK", "TABLE", MatchAnyExcept("ONLY")): case Matches("LOCK", "ONLY", MatchAny): case Matches("LOCK", "TABLE", "ONLY", MatchAny): - COMPLETE_WITH("IN", "NOWAIT"); + COMPLETE_WITH("IN", "NOWAIT"); break; - /* Complete LOCK [TABLE] [ONLY]
IN with a lock mode */ + /* Complete LOCK [TABLE] [ONLY]
IN with a lock mode */ case Matches("LOCK", MatchAnyN, "IN"): - COMPLETE_WITH("ACCESS SHARE MODE", - "ROW SHARE MODE", "ROW EXCLUSIVE MODE", - "SHARE UPDATE EXCLUSIVE MODE", "SHARE MODE", - "SHARE ROW EXCLUSIVE MODE", - "EXCLUSIVE MODE", "ACCESS EXCLUSIVE MODE"); + COMPLETE_WITH("ACCESS SHARE MODE", + "ROW SHARE MODE", "ROW EXCLUSIVE MODE", + "SHARE UPDATE EXCLUSIVE MODE", "SHARE MODE", + "SHARE ROW EXCLUSIVE MODE", + "EXCLUSIVE MODE", "ACCESS EXCLUSIVE MODE"); break; - /* - * Complete LOCK [TABLE][ONLY]
IN ACCESS|ROW with rest of lock - * mode - */ + /* + * Complete LOCK [TABLE][ONLY]
IN ACCESS|ROW with rest of + * lock mode + */ case Matches("LOCK", MatchAnyN, "IN", "ACCESS|ROW"): - COMPLETE_WITH("EXCLUSIVE MODE", "SHARE MODE"); + COMPLETE_WITH("EXCLUSIVE MODE", "SHARE MODE"); break; - /* Complete LOCK [TABLE] [ONLY]
IN SHARE with rest of lock mode */ + /* + * Complete LOCK [TABLE] [ONLY]
IN SHARE with rest of lock + * mode + */ case Matches("LOCK", MatchAnyN, "IN", "SHARE"): - COMPLETE_WITH("MODE", "ROW EXCLUSIVE MODE", - "UPDATE EXCLUSIVE MODE"); + COMPLETE_WITH("MODE", "ROW EXCLUSIVE MODE", + "UPDATE EXCLUSIVE MODE"); break; - /* Complete LOCK [TABLE] [ONLY]
[IN lockmode MODE] with "NOWAIT" */ + /* + * Complete LOCK [TABLE] [ONLY]
[IN lockmode MODE] with + * "NOWAIT" + */ case Matches("LOCK", MatchAnyN, "MODE"): - COMPLETE_WITH("NOWAIT"); + COMPLETE_WITH("NOWAIT"); break; /* MERGE --- can be inside EXPLAIN */ case TailMatches("MERGE"): - COMPLETE_WITH("INTO"); + COMPLETE_WITH("INTO"); break; case TailMatches("MERGE", "INTO"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_mergetargets); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_mergetargets); break; - /* Complete MERGE INTO
[[AS] ] with USING */ + /* Complete MERGE INTO
[[AS] ] with USING */ case TailMatches("MERGE", "INTO", MatchAny): - COMPLETE_WITH("USING", "AS"); + COMPLETE_WITH("USING", "AS"); break; case TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny): case TailMatches("MERGE", "INTO", MatchAny, MatchAnyExcept("USING|AS")): - COMPLETE_WITH("USING"); + COMPLETE_WITH("USING"); break; - /* - * Complete MERGE INTO ... USING with a list of relations supporting - * SELECT - */ + /* + * Complete MERGE INTO ... USING with a list of relations + * supporting SELECT + */ case TailMatches("MERGE", "INTO", MatchAny, "USING"): case TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING"): case TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); break; - /* - * Complete MERGE INTO
[[AS] ] USING [[AS] - * alias] with ON - */ + /* + * Complete MERGE INTO
[[AS] ] USING + * [[AS] alias] with ON + */ case TailMatches("MERGE", "INTO", MatchAny, "USING", MatchAny): case TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING", MatchAny): case TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING", MatchAny): - COMPLETE_WITH("AS", "ON"); + COMPLETE_WITH("AS", "ON"); break; case TailMatches("MERGE", "INTO", MatchAny, "USING", MatchAny, "AS", MatchAny): case TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING", MatchAny, "AS", MatchAny): @@ -5002,32 +5100,32 @@ match_previous_words(int pattern_id, case TailMatches("MERGE", "INTO", MatchAny, "USING", MatchAny, MatchAnyExcept("ON|AS")): case TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING", MatchAny, MatchAnyExcept("ON|AS")): case TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING", MatchAny, MatchAnyExcept("ON|AS")): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; - /* Complete MERGE INTO ... ON with target table attributes */ + /* Complete MERGE INTO ... ON with target table attributes */ case TailMatches("INTO", MatchAny, "USING", MatchAny, "ON"): - COMPLETE_WITH_ATTR(prev4_wd); + COMPLETE_WITH_ATTR(prev4_wd); break; case TailMatches("INTO", MatchAny, "AS", MatchAny, "USING", MatchAny, "AS", MatchAny, "ON"): - COMPLETE_WITH_ATTR(prev8_wd); + COMPLETE_WITH_ATTR(prev8_wd); break; case TailMatches("INTO", MatchAny, MatchAny, "USING", MatchAny, MatchAny, "ON"): - COMPLETE_WITH_ATTR(prev6_wd); + COMPLETE_WITH_ATTR(prev6_wd); break; - /* - * Complete ... USING [[AS] alias] ON join condition - * (consisting of one or three words typically used) with WHEN [NOT] - * MATCHED - */ + /* + * Complete ... USING [[AS] alias] ON join condition + * (consisting of one or three words typically used) with WHEN + * [NOT] MATCHED + */ case TailMatches("USING", MatchAny, "ON", MatchAny): case TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny): case TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny): case TailMatches("USING", MatchAny, "ON", MatchAny, MatchAnyExcept("WHEN"), MatchAnyExcept("WHEN")): case TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny, MatchAnyExcept("WHEN"), MatchAnyExcept("WHEN")): case TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny, MatchAnyExcept("WHEN"), MatchAnyExcept("WHEN")): - COMPLETE_WITH("WHEN MATCHED", "WHEN NOT MATCHED"); + COMPLETE_WITH("WHEN MATCHED", "WHEN NOT MATCHED"); break; case TailMatches("USING", MatchAny, "ON", MatchAny, "WHEN"): case TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny, "WHEN"): @@ -5035,72 +5133,73 @@ match_previous_words(int pattern_id, case TailMatches("USING", MatchAny, "ON", MatchAny, MatchAny, MatchAny, "WHEN"): case TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny, MatchAny, MatchAny, "WHEN"): case TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny, MatchAny, MatchAny, "WHEN"): - COMPLETE_WITH("MATCHED", "NOT MATCHED"); + COMPLETE_WITH("MATCHED", "NOT MATCHED"); break; - /* - * Complete ... WHEN MATCHED and WHEN NOT MATCHED BY SOURCE|TARGET with - * THEN/AND - */ + /* + * Complete ... WHEN MATCHED and WHEN NOT MATCHED BY SOURCE|TARGET + * with THEN/AND + */ case TailMatches("WHEN", "MATCHED"): case TailMatches("WHEN", "NOT", "MATCHED", "BY", "SOURCE|TARGET"): - COMPLETE_WITH("THEN", "AND"); + COMPLETE_WITH("THEN", "AND"); break; - /* Complete ... WHEN NOT MATCHED with BY/THEN/AND */ + /* Complete ... WHEN NOT MATCHED with BY/THEN/AND */ case TailMatches("WHEN", "NOT", "MATCHED"): - COMPLETE_WITH("BY", "THEN", "AND"); + COMPLETE_WITH("BY", "THEN", "AND"); break; - /* Complete ... WHEN NOT MATCHED BY with SOURCE/TARGET */ + /* Complete ... WHEN NOT MATCHED BY with SOURCE/TARGET */ case TailMatches("WHEN", "NOT", "MATCHED", "BY"): - COMPLETE_WITH("SOURCE", "TARGET"); + COMPLETE_WITH("SOURCE", "TARGET"); break; - /* - * Complete ... WHEN MATCHED THEN and WHEN NOT MATCHED BY SOURCE THEN with - * UPDATE SET/DELETE/DO NOTHING - */ + /* + * Complete ... WHEN MATCHED THEN and WHEN NOT MATCHED BY SOURCE + * THEN with UPDATE SET/DELETE/DO NOTHING + */ case TailMatches("WHEN", "MATCHED", "THEN"): case TailMatches("WHEN", "NOT", "MATCHED", "BY", "SOURCE", "THEN"): - COMPLETE_WITH("UPDATE SET", "DELETE", "DO NOTHING"); + COMPLETE_WITH("UPDATE SET", "DELETE", "DO NOTHING"); break; - /* - * Complete ... WHEN NOT MATCHED [BY TARGET] THEN with INSERT/DO NOTHING - */ + /* + * Complete ... WHEN NOT MATCHED [BY TARGET] THEN with INSERT/DO + * NOTHING + */ case TailMatches("WHEN", "NOT", "MATCHED", "THEN"): case TailMatches("WHEN", "NOT", "MATCHED", "BY", "TARGET", "THEN"): - COMPLETE_WITH("INSERT", "DO NOTHING"); + COMPLETE_WITH("INSERT", "DO NOTHING"); break; /* NOTIFY --- can be inside EXPLAIN, RULE, etc */ case TailMatches("NOTIFY"): - COMPLETE_WITH_QUERY(Query_for_list_of_channels); + COMPLETE_WITH_QUERY(Query_for_list_of_channels); break; /* OPTIONS */ case TailMatches("OPTIONS"): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; /* OWNER TO - complete with available roles */ case TailMatches("OWNER", "TO"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - Keywords_for_list_of_owner_roles); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + Keywords_for_list_of_owner_roles); break; /* ORDER BY */ case TailMatches("FROM", MatchAny, "ORDER"): - COMPLETE_WITH("BY"); + COMPLETE_WITH("BY"); break; case TailMatches("FROM", MatchAny, "ORDER", "BY"): - COMPLETE_WITH_ATTR(prev3_wd); + COMPLETE_WITH_ATTR(prev3_wd); break; /* PREPARE xx AS */ case Matches("PREPARE", MatchAny, "AS"): - COMPLETE_WITH("SELECT", "UPDATE", "INSERT INTO", "DELETE FROM"); + COMPLETE_WITH("SELECT", "UPDATE", "INSERT INTO", "DELETE FROM"); break; /* @@ -5110,368 +5209,372 @@ match_previous_words(int pattern_id, /* REASSIGN OWNED BY xxx TO yyy */ case Matches("REASSIGN"): - COMPLETE_WITH("OWNED BY"); + COMPLETE_WITH("OWNED BY"); break; case Matches("REASSIGN", "OWNED"): - COMPLETE_WITH("BY"); + COMPLETE_WITH("BY"); break; case Matches("REASSIGN", "OWNED", "BY"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; case Matches("REASSIGN", "OWNED", "BY", MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; case Matches("REASSIGN", "OWNED", "BY", MatchAny, "TO"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; /* REFRESH MATERIALIZED VIEW */ case Matches("REFRESH"): - COMPLETE_WITH("MATERIALIZED VIEW"); + COMPLETE_WITH("MATERIALIZED VIEW"); break; case Matches("REFRESH", "MATERIALIZED"): - COMPLETE_WITH("VIEW"); + COMPLETE_WITH("VIEW"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_matviews, - "CONCURRENTLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_matviews, + "CONCURRENTLY"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", MatchAny): - COMPLETE_WITH("WITH"); + COMPLETE_WITH("WITH"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY", MatchAny): - COMPLETE_WITH("WITH"); + COMPLETE_WITH("WITH"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", MatchAny, "WITH"): - COMPLETE_WITH("NO DATA", "DATA"); + COMPLETE_WITH("NO DATA", "DATA"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY", MatchAny, "WITH"): - COMPLETE_WITH("NO DATA", "DATA"); + COMPLETE_WITH("NO DATA", "DATA"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", MatchAny, "WITH", "NO"): - COMPLETE_WITH("DATA"); + COMPLETE_WITH("DATA"); break; case Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY", MatchAny, "WITH", "NO"): - COMPLETE_WITH("DATA"); + COMPLETE_WITH("DATA"); break; /* REINDEX */ case Matches("REINDEX"): case Matches("REINDEX", "(*)"): - COMPLETE_WITH("TABLE", "INDEX", "SYSTEM", "SCHEMA", "DATABASE"); + COMPLETE_WITH("TABLE", "INDEX", "SYSTEM", "SCHEMA", "DATABASE"); break; case Matches("REINDEX", "TABLE"): case Matches("REINDEX", "(*)", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexables, - "CONCURRENTLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexables, + "CONCURRENTLY"); break; case Matches("REINDEX", "INDEX"): case Matches("REINDEX", "(*)", "INDEX"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, - "CONCURRENTLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes, + "CONCURRENTLY"); break; case Matches("REINDEX", "SCHEMA"): case Matches("REINDEX", "(*)", "SCHEMA"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas, - "CONCURRENTLY"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas, + "CONCURRENTLY"); break; case Matches("REINDEX", "SYSTEM|DATABASE"): case Matches("REINDEX", "(*)", "SYSTEM|DATABASE"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_databases, - "CONCURRENTLY"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_databases, + "CONCURRENTLY"); break; case Matches("REINDEX", "TABLE", "CONCURRENTLY"): case Matches("REINDEX", "(*)", "TABLE", "CONCURRENTLY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexables); break; case Matches("REINDEX", "INDEX", "CONCURRENTLY"): case Matches("REINDEX", "(*)", "INDEX", "CONCURRENTLY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); break; case Matches("REINDEX", "SCHEMA", "CONCURRENTLY"): case Matches("REINDEX", "(*)", "SCHEMA", "CONCURRENTLY"): - COMPLETE_WITH_QUERY(Query_for_list_of_schemas); + COMPLETE_WITH_QUERY(Query_for_list_of_schemas); break; case Matches("REINDEX", "SYSTEM|DATABASE", "CONCURRENTLY"): case Matches("REINDEX", "(*)", "SYSTEM|DATABASE", "CONCURRENTLY"): - COMPLETE_WITH_QUERY(Query_for_list_of_databases); + COMPLETE_WITH_QUERY(Query_for_list_of_databases); break; case HeadMatches("REINDEX", "(*"): - if (!HeadMatches("REINDEX", "(*)")) - { - /* - * This fires if we're in an unfinished parenthesized option list. - * get_previous_words treats a completed parenthesized option list as - * one word, so the above test is correct. - */ - if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) - COMPLETE_WITH("CONCURRENTLY", "TABLESPACE", "VERBOSE"); - else if (TailMatches("TABLESPACE")) - COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); - } + if (!HeadMatches("REINDEX", "(*)")) + { + /* + * This fires if we're in an unfinished parenthesized option + * list. get_previous_words treats a completed parenthesized + * option list as one word, so the above test is correct. + */ + if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) + COMPLETE_WITH("CONCURRENTLY", "TABLESPACE", "VERBOSE"); + else if (TailMatches("TABLESPACE")) + COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); + } break; /* SECURITY LABEL */ case Matches("SECURITY"): - COMPLETE_WITH("LABEL"); + COMPLETE_WITH("LABEL"); break; case Matches("SECURITY", "LABEL"): - COMPLETE_WITH("ON", "FOR"); + COMPLETE_WITH("ON", "FOR"); break; case Matches("SECURITY", "LABEL", "FOR", MatchAny): - COMPLETE_WITH("ON"); + COMPLETE_WITH("ON"); break; case Matches("SECURITY", "LABEL", "ON"): case Matches("SECURITY", "LABEL", "FOR", MatchAny, "ON"): - COMPLETE_WITH("TABLE", "COLUMN", "AGGREGATE", "DATABASE", "DOMAIN", - "EVENT TRIGGER", "FOREIGN TABLE", "FUNCTION", - "LARGE OBJECT", "MATERIALIZED VIEW", "LANGUAGE", - "PUBLICATION", "PROCEDURE", "ROLE", "ROUTINE", "SCHEMA", - "SEQUENCE", "SUBSCRIPTION", "TABLESPACE", "TYPE", "VIEW"); + COMPLETE_WITH("TABLE", "COLUMN", "AGGREGATE", "DATABASE", "DOMAIN", + "EVENT TRIGGER", "FOREIGN TABLE", "FUNCTION", + "LARGE OBJECT", "MATERIALIZED VIEW", "LANGUAGE", + "PUBLICATION", "PROCEDURE", "ROLE", "ROUTINE", "SCHEMA", + "SEQUENCE", "SUBSCRIPTION", "TABLESPACE", "TYPE", "VIEW"); break; case Matches("SECURITY", "LABEL", "ON", MatchAny, MatchAny): - COMPLETE_WITH("IS"); + COMPLETE_WITH("IS"); break; /* SELECT */ - /* naah . . . */ + /* naah . . . */ /* SET, RESET, SHOW */ - /* Complete with a variable name */ + /* Complete with a variable name */ case TailMatches("SET|RESET"): - if (!TailMatches("UPDATE", MatchAny, "SET")) - COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars, - "CONSTRAINTS", - "TRANSACTION", - "SESSION", - "ROLE", - "TABLESPACE", - "ALL"); + if (!TailMatches("UPDATE", MatchAny, "SET")) + COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars, + "CONSTRAINTS", + "TRANSACTION", + "SESSION", + "ROLE", + "TABLESPACE", + "ALL"); break; case Matches("SHOW"): - COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_show_vars, - "SESSION AUTHORIZATION", - "ALL"); + COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_show_vars, + "SESSION AUTHORIZATION", + "ALL"); break; case Matches("SHOW", "SESSION"): - COMPLETE_WITH("AUTHORIZATION"); + COMPLETE_WITH("AUTHORIZATION"); break; - /* Complete "SET TRANSACTION" */ + /* Complete "SET TRANSACTION" */ case Matches("SET", "TRANSACTION"): - COMPLETE_WITH("SNAPSHOT", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE"); + COMPLETE_WITH("SNAPSHOT", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE"); break; case Matches("BEGIN|START", "TRANSACTION"): case Matches("BEGIN", "WORK"): case Matches("BEGIN"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION"): - COMPLETE_WITH("ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE"); + COMPLETE_WITH("ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE"); break; case Matches("SET|BEGIN|START", "TRANSACTION|WORK", "NOT"): case Matches("BEGIN", "NOT"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "NOT"): - COMPLETE_WITH("DEFERRABLE"); + COMPLETE_WITH("DEFERRABLE"); break; case Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION"): case Matches("BEGIN", "ISOLATION"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION"): - COMPLETE_WITH("LEVEL"); + COMPLETE_WITH("LEVEL"); break; case Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION", "LEVEL"): case Matches("BEGIN", "ISOLATION", "LEVEL"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION", "LEVEL"): - COMPLETE_WITH("READ", "REPEATABLE READ", "SERIALIZABLE"); + COMPLETE_WITH("READ", "REPEATABLE READ", "SERIALIZABLE"); break; case Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION", "LEVEL", "READ"): case Matches("BEGIN", "ISOLATION", "LEVEL", "READ"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION", "LEVEL", "READ"): - COMPLETE_WITH("UNCOMMITTED", "COMMITTED"); + COMPLETE_WITH("UNCOMMITTED", "COMMITTED"); break; case Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION", "LEVEL", "REPEATABLE"): case Matches("BEGIN", "ISOLATION", "LEVEL", "REPEATABLE"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION", "LEVEL", "REPEATABLE"): - COMPLETE_WITH("READ"); + COMPLETE_WITH("READ"); break; case Matches("SET|BEGIN|START", "TRANSACTION|WORK", "READ"): case Matches("BEGIN", "READ"): case Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "READ"): - COMPLETE_WITH("ONLY", "WRITE"); + COMPLETE_WITH("ONLY", "WRITE"); break; - /* SET CONSTRAINTS */ + /* SET CONSTRAINTS */ case Matches("SET", "CONSTRAINTS"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_constraints_with_schema, - "ALL"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_constraints_with_schema, + "ALL"); break; - /* Complete SET CONSTRAINTS with DEFERRED|IMMEDIATE */ + /* Complete SET CONSTRAINTS with DEFERRED|IMMEDIATE */ case Matches("SET", "CONSTRAINTS", MatchAny): - COMPLETE_WITH("DEFERRED", "IMMEDIATE"); + COMPLETE_WITH("DEFERRED", "IMMEDIATE"); break; - /* Complete SET ROLE */ + /* Complete SET ROLE */ case Matches("SET", "ROLE"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; - /* Complete SET SESSION with AUTHORIZATION or CHARACTERISTICS... */ + /* Complete SET SESSION with AUTHORIZATION or CHARACTERISTICS... */ case Matches("SET", "SESSION"): - COMPLETE_WITH("AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION"); + COMPLETE_WITH("AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION"); break; - /* Complete SET SESSION AUTHORIZATION with username */ + /* Complete SET SESSION AUTHORIZATION with username */ case Matches("SET", "SESSION", "AUTHORIZATION"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - "DEFAULT"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + "DEFAULT"); break; - /* Complete RESET SESSION with AUTHORIZATION */ + /* Complete RESET SESSION with AUTHORIZATION */ case Matches("RESET", "SESSION"): - COMPLETE_WITH("AUTHORIZATION"); + COMPLETE_WITH("AUTHORIZATION"); break; - /* Complete SET with "TO" */ + /* Complete SET with "TO" */ case Matches("SET", MatchAny): - COMPLETE_WITH("TO"); + COMPLETE_WITH("TO"); break; - /* - * Complete ALTER DATABASE|FUNCTION|PROCEDURE|ROLE|ROUTINE|USER ... SET - * - */ + /* + * Complete ALTER DATABASE|FUNCTION|PROCEDURE|ROLE|ROUTINE|USER + * ... SET + */ case Matches("ALTER", "DATABASE|FUNCTION|PROCEDURE|ROLE|ROUTINE|USER", MatchAnyN, "SET", MatchAnyExcept("SCHEMA")): - COMPLETE_WITH("FROM CURRENT", "TO"); + COMPLETE_WITH("FROM CURRENT", "TO"); break; - /* - * Suggest possible variable values in SET variable TO|=, along with the - * preceding ALTER syntaxes. - */ - case TailMatches("SET", MatchAny, "TO|="): - if (!TailMatches("UPDATE", MatchAny, "SET", MatchAny, "TO|=")) - { - /* special cased code for individual GUCs */ - if (TailMatches("DateStyle", "TO|=")) - COMPLETE_WITH("ISO", "SQL", "Postgres", "German", - "YMD", "DMY", "MDY", - "US", "European", "NonEuropean", - "DEFAULT"); - else if (TailMatches("search_path", "TO|=")) - { - /* Here, we want to allow pg_catalog, so use narrower exclusion */ - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas - " AND nspname NOT LIKE E'pg\\\\_toast%%'" - " AND nspname NOT LIKE E'pg\\\\_temp%%'", - "DEFAULT"); - } - else if (TailMatches("TimeZone", "TO|=")) - COMPLETE_WITH_TIMEZONE_NAME(); - else - { - /* generic, type based, GUC support */ - char *guctype = get_guctype(prev2_wd); - /* - * Note: if we don't recognize the GUC name, it's important to not - * offer any completions, as most likely we've misinterpreted the - * context and this isn't a GUC-setting command at all. + * Suggest possible variable values in SET variable TO|=, along + * with the preceding ALTER syntaxes. */ - if (guctype) + case TailMatches("SET", MatchAny, "TO|="): + if (!TailMatches("UPDATE", MatchAny, "SET", MatchAny, "TO|=")) { - if (strcmp(guctype, "enum") == 0) + /* special cased code for individual GUCs */ + if (TailMatches("DateStyle", "TO|=")) + COMPLETE_WITH("ISO", "SQL", "Postgres", "German", + "YMD", "DMY", "MDY", + "US", "European", "NonEuropean", + "DEFAULT"); + else if (TailMatches("search_path", "TO|=")) { - set_completion_reference_verbatim(prev2_wd); - COMPLETE_WITH_QUERY_PLUS(Query_for_values_of_enum_GUC, + /* + * Here, we want to allow pg_catalog, so use narrower + * exclusion + */ + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas + " AND nspname NOT LIKE E'pg\\\\_toast%%'" + " AND nspname NOT LIKE E'pg\\\\_temp%%'", "DEFAULT"); } - else if (strcmp(guctype, "bool") == 0) - COMPLETE_WITH("on", "off", "true", "false", "yes", "no", - "1", "0", "DEFAULT"); + else if (TailMatches("TimeZone", "TO|=")) + COMPLETE_WITH_TIMEZONE_NAME(); else - COMPLETE_WITH("DEFAULT"); + { + /* generic, type based, GUC support */ + char *guctype = get_guctype(prev2_wd); - free(guctype); + /* + * Note: if we don't recognize the GUC name, it's + * important to not offer any completions, as most likely + * we've misinterpreted the context and this isn't a + * GUC-setting command at all. + */ + if (guctype) + { + if (strcmp(guctype, "enum") == 0) + { + set_completion_reference_verbatim(prev2_wd); + COMPLETE_WITH_QUERY_PLUS(Query_for_values_of_enum_GUC, + "DEFAULT"); + } + else if (strcmp(guctype, "bool") == 0) + COMPLETE_WITH("on", "off", "true", "false", "yes", "no", + "1", "0", "DEFAULT"); + else + COMPLETE_WITH("DEFAULT"); + + free(guctype); + } + } } - } - } break; /* START TRANSACTION */ case Matches("START"): - COMPLETE_WITH("TRANSACTION"); + COMPLETE_WITH("TRANSACTION"); break; /* TABLE, but not TABLE embedded in other commands */ case Matches("TABLE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); break; /* TABLESAMPLE */ case TailMatches("TABLESAMPLE"): - COMPLETE_WITH_QUERY(Query_for_list_of_tablesample_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_tablesample_methods); break; case TailMatches("TABLESAMPLE", MatchAny): - COMPLETE_WITH("("); + COMPLETE_WITH("("); break; /* TRUNCATE */ case Matches("TRUNCATE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_truncatables, - "TABLE", "ONLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_truncatables, + "TABLE", "ONLY"); break; case Matches("TRUNCATE", "TABLE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_truncatables, - "ONLY"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_truncatables, + "ONLY"); break; case Matches("TRUNCATE", MatchAnyN, "ONLY"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_truncatables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_truncatables); break; case Matches("TRUNCATE", MatchAny): case Matches("TRUNCATE", "TABLE|ONLY", MatchAny): case Matches("TRUNCATE", "TABLE", "ONLY", MatchAny): - COMPLETE_WITH("RESTART IDENTITY", "CONTINUE IDENTITY", "CASCADE", "RESTRICT"); + COMPLETE_WITH("RESTART IDENTITY", "CONTINUE IDENTITY", "CASCADE", "RESTRICT"); break; case Matches("TRUNCATE", MatchAnyN, "IDENTITY"): - COMPLETE_WITH("CASCADE", "RESTRICT"); + COMPLETE_WITH("CASCADE", "RESTRICT"); break; /* UNLISTEN */ case Matches("UNLISTEN"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_channels, "*"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_channels, "*"); break; /* UPDATE --- can be inside EXPLAIN, RULE, etc */ - /* If prev. word is UPDATE suggest a list of tables */ + /* If prev. word is UPDATE suggest a list of tables */ case TailMatches("UPDATE"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables); break; - /* Complete UPDATE
with "SET" */ + /* Complete UPDATE
with "SET" */ case TailMatches("UPDATE", MatchAny): - COMPLETE_WITH("SET"); + COMPLETE_WITH("SET"); break; - /* Complete UPDATE
SET with list of attributes */ + /* Complete UPDATE
SET with list of attributes */ case TailMatches("UPDATE", MatchAny, "SET"): - COMPLETE_WITH_ATTR(prev2_wd); + COMPLETE_WITH_ATTR(prev2_wd); break; - /* UPDATE
SET = */ + /* UPDATE
SET = */ case TailMatches("UPDATE", MatchAny, "SET", MatchAnyExcept("*=")): - COMPLETE_WITH("="); + COMPLETE_WITH("="); break; /* USER MAPPING */ case Matches("ALTER|CREATE|DROP", "USER", "MAPPING"): - COMPLETE_WITH("FOR"); + COMPLETE_WITH("FOR"); break; case Matches("CREATE", "USER", "MAPPING", "FOR"): - COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, - "CURRENT_ROLE", - "CURRENT_USER", - "PUBLIC", - "USER"); + COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles, + "CURRENT_ROLE", + "CURRENT_USER", + "PUBLIC", + "USER"); break; case Matches("ALTER|DROP", "USER", "MAPPING", "FOR"): - COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings); + COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings); break; case Matches("CREATE|ALTER|DROP", "USER", "MAPPING", "FOR", MatchAny): - COMPLETE_WITH("SERVER"); + COMPLETE_WITH("SERVER"); break; case Matches("CREATE|ALTER", "USER", "MAPPING", "FOR", MatchAny, "SERVER", MatchAny): - COMPLETE_WITH("OPTIONS"); + COMPLETE_WITH("OPTIONS"); break; /* @@ -5479,352 +5582,352 @@ match_previous_words(int pattern_id, * VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ ANALYZE ] [ table_and_columns [, ...] ] */ case Matches("VACUUM"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, - "FULL", - "FREEZE", - "ANALYZE", - "VERBOSE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, + "FULL", + "FREEZE", + "ANALYZE", + "VERBOSE"); break; case Matches("VACUUM", "FULL"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, - "FREEZE", - "ANALYZE", - "VERBOSE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, + "FREEZE", + "ANALYZE", + "VERBOSE"); break; case Matches("VACUUM", "FREEZE"): case Matches("VACUUM", "FULL", "FREEZE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, - "VERBOSE", - "ANALYZE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, + "VERBOSE", + "ANALYZE"); break; case Matches("VACUUM", "VERBOSE"): case Matches("VACUUM", "FULL|FREEZE", "VERBOSE"): case Matches("VACUUM", "FULL", "FREEZE", "VERBOSE"): - COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, - "ANALYZE"); + COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables, + "ANALYZE"); break; case HeadMatches("VACUUM", "(*"): - if (!HeadMatches("VACUUM", "(*)")) - { - /* - * This fires if we're in an unfinished parenthesized option list. - * get_previous_words treats a completed parenthesized option list as - * one word, so the above test is correct. - */ - if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) - COMPLETE_WITH("FULL", "FREEZE", "ANALYZE", "VERBOSE", - "DISABLE_PAGE_SKIPPING", "SKIP_LOCKED", - "INDEX_CLEANUP", "PROCESS_MAIN", "PROCESS_TOAST", - "TRUNCATE", "PARALLEL", "SKIP_DATABASE_STATS", - "ONLY_DATABASE_STATS", "BUFFER_USAGE_LIMIT"); - else if (TailMatches("FULL|FREEZE|ANALYZE|VERBOSE|DISABLE_PAGE_SKIPPING|SKIP_LOCKED|PROCESS_MAIN|PROCESS_TOAST|TRUNCATE|SKIP_DATABASE_STATS|ONLY_DATABASE_STATS")) - COMPLETE_WITH("ON", "OFF"); - else if (TailMatches("INDEX_CLEANUP")) - COMPLETE_WITH("AUTO", "ON", "OFF"); - } + if (!HeadMatches("VACUUM", "(*)")) + { + /* + * This fires if we're in an unfinished parenthesized option + * list. get_previous_words treats a completed parenthesized + * option list as one word, so the above test is correct. + */ + if (ends_with(prev_wd, '(') || ends_with(prev_wd, ',')) + COMPLETE_WITH("FULL", "FREEZE", "ANALYZE", "VERBOSE", + "DISABLE_PAGE_SKIPPING", "SKIP_LOCKED", + "INDEX_CLEANUP", "PROCESS_MAIN", "PROCESS_TOAST", + "TRUNCATE", "PARALLEL", "SKIP_DATABASE_STATS", + "ONLY_DATABASE_STATS", "BUFFER_USAGE_LIMIT"); + else if (TailMatches("FULL|FREEZE|ANALYZE|VERBOSE|DISABLE_PAGE_SKIPPING|SKIP_LOCKED|PROCESS_MAIN|PROCESS_TOAST|TRUNCATE|SKIP_DATABASE_STATS|ONLY_DATABASE_STATS")) + COMPLETE_WITH("ON", "OFF"); + else if (TailMatches("INDEX_CLEANUP")) + COMPLETE_WITH("AUTO", "ON", "OFF"); + } break; case Matches("VACUUM", MatchAnyN, "("): - /* "VACUUM (" should be caught above, so assume we want columns */ - COMPLETE_WITH_ATTR(prev2_wd); + /* "VACUUM (" should be caught above, so assume we want columns */ + COMPLETE_WITH_ATTR(prev2_wd); break; case HeadMatches("VACUUM"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_vacuumables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_vacuumables); break; /* WITH [RECURSIVE] */ - /* - * Only match when WITH is the first word, as WITH may appear in many - * other contexts. - */ + /* + * Only match when WITH is the first word, as WITH may appear in + * many other contexts. + */ case Matches("WITH"): - COMPLETE_WITH("RECURSIVE"); + COMPLETE_WITH("RECURSIVE"); break; /* WHERE */ - /* Simple case of the word before the where being the table name */ + /* Simple case of the word before the where being the table name */ case TailMatches(MatchAny, "WHERE"): - COMPLETE_WITH_ATTR(prev2_wd); + COMPLETE_WITH_ATTR(prev2_wd); break; /* ... FROM ... */ /* TODO: also include SRF ? */ case TailMatches("FROM"): - if (!Matches("COPY|\\copy", MatchAny, "FROM")) - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); + if (!Matches("COPY|\\copy", MatchAny, "FROM")) + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); break; /* ... JOIN ... */ case TailMatches("JOIN"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables); break; /* ... AT [ LOCAL | TIME ZONE ] ... */ case TailMatches("AT"): - COMPLETE_WITH("LOCAL", "TIME ZONE"); + COMPLETE_WITH("LOCAL", "TIME ZONE"); break; case TailMatches("AT", "TIME", "ZONE"): - COMPLETE_WITH_TIMEZONE_NAME(); + COMPLETE_WITH_TIMEZONE_NAME(); break; /* Backslash commands */ /* TODO: \dc \dd \dl */ case TailMatchesCS("\\?"): - COMPLETE_WITH_CS("commands", "options", "variables"); + COMPLETE_WITH_CS("commands", "options", "variables"); break; case TailMatchesCS("\\connect|\\c"): - if (!recognized_connection_string(text)) - COMPLETE_WITH_QUERY(Query_for_list_of_databases); + if (!recognized_connection_string(text)) + COMPLETE_WITH_QUERY(Query_for_list_of_databases); break; case TailMatchesCS("\\connect|\\c", MatchAny): - if (!recognized_connection_string(prev_wd)) - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + if (!recognized_connection_string(prev_wd)) + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; case TailMatchesCS("\\da*"): - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_aggregates); + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_aggregates); break; case TailMatchesCS("\\dAc*", MatchAny): case TailMatchesCS("\\dAf*", MatchAny): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case TailMatchesCS("\\dAo*", MatchAny): case TailMatchesCS("\\dAp*", MatchAny): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_operator_families); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_operator_families); break; case TailMatchesCS("\\dA*"): - COMPLETE_WITH_QUERY(Query_for_list_of_access_methods); + COMPLETE_WITH_QUERY(Query_for_list_of_access_methods); break; case TailMatchesCS("\\db*"): - COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); + COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces); break; case TailMatchesCS("\\dconfig*"): - COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_show_vars); + COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_show_vars); break; case TailMatchesCS("\\dD*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains); break; case TailMatchesCS("\\des*"): - COMPLETE_WITH_QUERY(Query_for_list_of_servers); + COMPLETE_WITH_QUERY(Query_for_list_of_servers); break; case TailMatchesCS("\\deu*"): - COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings); + COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings); break; case TailMatchesCS("\\dew*"): - COMPLETE_WITH_QUERY(Query_for_list_of_fdws); + COMPLETE_WITH_QUERY(Query_for_list_of_fdws); break; case TailMatchesCS("\\df*"): - COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); + COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions); break; case HeadMatchesCS("\\df*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case TailMatchesCS("\\dFd*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_dictionaries); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_dictionaries); break; case TailMatchesCS("\\dFp*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_parsers); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_parsers); break; case TailMatchesCS("\\dFt*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_templates); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_templates); break; - /* must be at end of \dF alternatives: */ + /* must be at end of \dF alternatives: */ case TailMatchesCS("\\dF*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_configurations); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_configurations); break; case TailMatchesCS("\\di*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes); break; case TailMatchesCS("\\dL*"): - COMPLETE_WITH_QUERY(Query_for_list_of_languages); + COMPLETE_WITH_QUERY(Query_for_list_of_languages); break; case TailMatchesCS("\\dn*"): - COMPLETE_WITH_QUERY(Query_for_list_of_schemas); + COMPLETE_WITH_QUERY(Query_for_list_of_schemas); break; - /* no support for completing operators, but we can complete types: */ + /* no support for completing operators, but we can complete types: */ case HeadMatchesCS("\\do*", MatchAny): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case TailMatchesCS("\\dp"): case TailMatchesCS("\\z"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_grantables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_grantables); break; case TailMatchesCS("\\dPi*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_indexes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_indexes); break; case TailMatchesCS("\\dPt*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables); break; case TailMatchesCS("\\dP*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_relations); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_relations); break; case TailMatchesCS("\\dRp*"): - COMPLETE_WITH_VERSIONED_QUERY(Query_for_list_of_publications); + COMPLETE_WITH_VERSIONED_QUERY(Query_for_list_of_publications); break; case TailMatchesCS("\\dRs*"): - COMPLETE_WITH_VERSIONED_QUERY(Query_for_list_of_subscriptions); + COMPLETE_WITH_VERSIONED_QUERY(Query_for_list_of_subscriptions); break; case TailMatchesCS("\\ds*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences); break; case TailMatchesCS("\\dt*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables); break; case TailMatchesCS("\\dT*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes); break; case TailMatchesCS("\\du*"): case TailMatchesCS("\\dg*"): case TailMatchesCS("\\drg*"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; case TailMatchesCS("\\dv*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); break; case TailMatchesCS("\\dx*"): - COMPLETE_WITH_QUERY(Query_for_list_of_extensions); + COMPLETE_WITH_QUERY(Query_for_list_of_extensions); break; case TailMatchesCS("\\dX*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_statistics); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_statistics); break; case TailMatchesCS("\\dm*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews); break; case TailMatchesCS("\\dE*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables); break; case TailMatchesCS("\\dy*"): - COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); + COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers); break; - /* must be at end of \d alternatives: */ + /* must be at end of \d alternatives: */ case TailMatchesCS("\\d*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_relations); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_relations); break; case TailMatchesCS("\\ef"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines); break; case TailMatchesCS("\\ev"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); break; case TailMatchesCS("\\encoding"): - COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_encodings); + COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_encodings); break; case TailMatchesCS("\\h|\\help"): - COMPLETE_WITH_LIST(sql_commands); + COMPLETE_WITH_LIST(sql_commands); break; case TailMatchesCS("\\h|\\help", MatchAny): - if (TailMatches("DROP")) - matches = rl_completion_matches(text, drop_command_generator); - else if (TailMatches("ALTER")) - matches = rl_completion_matches(text, alter_command_generator); + if (TailMatches("DROP")) + matches = rl_completion_matches(text, drop_command_generator); + else if (TailMatches("ALTER")) + matches = rl_completion_matches(text, alter_command_generator); - /* - * CREATE is recognized by tail match elsewhere, so doesn't need to be - * repeated here - */ + /* + * CREATE is recognized by tail match elsewhere, so doesn't need + * to be repeated here + */ break; case TailMatchesCS("\\h|\\help", MatchAny, MatchAny): - if (TailMatches("CREATE|DROP", "ACCESS")) - COMPLETE_WITH("METHOD"); - else if (TailMatches("ALTER", "DEFAULT")) - COMPLETE_WITH("PRIVILEGES"); - else if (TailMatches("CREATE|ALTER|DROP", "EVENT")) - COMPLETE_WITH("TRIGGER"); - else if (TailMatches("CREATE|ALTER|DROP", "FOREIGN")) - COMPLETE_WITH("DATA WRAPPER", "TABLE"); - else if (TailMatches("ALTER", "LARGE")) - COMPLETE_WITH("OBJECT"); - else if (TailMatches("CREATE|ALTER|DROP", "MATERIALIZED")) - COMPLETE_WITH("VIEW"); - else if (TailMatches("CREATE|ALTER|DROP", "TEXT")) - COMPLETE_WITH("SEARCH"); - else if (TailMatches("CREATE|ALTER|DROP", "USER")) - COMPLETE_WITH("MAPPING FOR"); + if (TailMatches("CREATE|DROP", "ACCESS")) + COMPLETE_WITH("METHOD"); + else if (TailMatches("ALTER", "DEFAULT")) + COMPLETE_WITH("PRIVILEGES"); + else if (TailMatches("CREATE|ALTER|DROP", "EVENT")) + COMPLETE_WITH("TRIGGER"); + else if (TailMatches("CREATE|ALTER|DROP", "FOREIGN")) + COMPLETE_WITH("DATA WRAPPER", "TABLE"); + else if (TailMatches("ALTER", "LARGE")) + COMPLETE_WITH("OBJECT"); + else if (TailMatches("CREATE|ALTER|DROP", "MATERIALIZED")) + COMPLETE_WITH("VIEW"); + else if (TailMatches("CREATE|ALTER|DROP", "TEXT")) + COMPLETE_WITH("SEARCH"); + else if (TailMatches("CREATE|ALTER|DROP", "USER")) + COMPLETE_WITH("MAPPING FOR"); break; case TailMatchesCS("\\h|\\help", MatchAny, MatchAny, MatchAny): - if (TailMatches("CREATE|ALTER|DROP", "FOREIGN", "DATA")) - COMPLETE_WITH("WRAPPER"); - else if (TailMatches("CREATE|ALTER|DROP", "TEXT", "SEARCH")) - COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); - else if (TailMatches("CREATE|ALTER|DROP", "USER", "MAPPING")) - COMPLETE_WITH("FOR"); + if (TailMatches("CREATE|ALTER|DROP", "FOREIGN", "DATA")) + COMPLETE_WITH("WRAPPER"); + else if (TailMatches("CREATE|ALTER|DROP", "TEXT", "SEARCH")) + COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE"); + else if (TailMatches("CREATE|ALTER|DROP", "USER", "MAPPING")) + COMPLETE_WITH("FOR"); break; case TailMatchesCS("\\l*"): - if (!TailMatchesCS("\\lo*")) - COMPLETE_WITH_QUERY(Query_for_list_of_databases); + if (!TailMatchesCS("\\lo*")) + COMPLETE_WITH_QUERY(Query_for_list_of_databases); break; case TailMatchesCS("\\password"): - COMPLETE_WITH_QUERY(Query_for_list_of_roles); + COMPLETE_WITH_QUERY(Query_for_list_of_roles); break; case TailMatchesCS("\\pset"): - COMPLETE_WITH_CS("border", "columns", "csv_fieldsep", "expanded", - "fieldsep", "fieldsep_zero", "footer", "format", - "linestyle", "null", "numericlocale", - "pager", "pager_min_lines", - "recordsep", "recordsep_zero", - "tableattr", "title", "tuples_only", - "unicode_border_linestyle", - "unicode_column_linestyle", - "unicode_header_linestyle", - "xheader_width"); + COMPLETE_WITH_CS("border", "columns", "csv_fieldsep", "expanded", + "fieldsep", "fieldsep_zero", "footer", "format", + "linestyle", "null", "numericlocale", + "pager", "pager_min_lines", + "recordsep", "recordsep_zero", + "tableattr", "title", "tuples_only", + "unicode_border_linestyle", + "unicode_column_linestyle", + "unicode_header_linestyle", + "xheader_width"); break; case TailMatchesCS("\\pset", MatchAny): - if (TailMatchesCS("format")) - COMPLETE_WITH_CS("aligned", "asciidoc", "csv", "html", "latex", - "latex-longtable", "troff-ms", "unaligned", - "wrapped"); - else if (TailMatchesCS("xheader_width")) - COMPLETE_WITH_CS("full", "column", "page"); - else if (TailMatchesCS("linestyle")) - COMPLETE_WITH_CS("ascii", "old-ascii", "unicode"); - else if (TailMatchesCS("pager")) - COMPLETE_WITH_CS("on", "off", "always"); - else if (TailMatchesCS("unicode_border_linestyle|" - "unicode_column_linestyle|" - "unicode_header_linestyle")) - COMPLETE_WITH_CS("single", "double"); + if (TailMatchesCS("format")) + COMPLETE_WITH_CS("aligned", "asciidoc", "csv", "html", "latex", + "latex-longtable", "troff-ms", "unaligned", + "wrapped"); + else if (TailMatchesCS("xheader_width")) + COMPLETE_WITH_CS("full", "column", "page"); + else if (TailMatchesCS("linestyle")) + COMPLETE_WITH_CS("ascii", "old-ascii", "unicode"); + else if (TailMatchesCS("pager")) + COMPLETE_WITH_CS("on", "off", "always"); + else if (TailMatchesCS("unicode_border_linestyle|" + "unicode_column_linestyle|" + "unicode_header_linestyle")) + COMPLETE_WITH_CS("single", "double"); break; case TailMatchesCS("\\unset"): - matches = complete_from_variables(text, "", "", true); + matches = complete_from_variables(text, "", "", true); break; case TailMatchesCS("\\set"): - matches = complete_from_variables(text, "", "", false); + matches = complete_from_variables(text, "", "", false); break; case TailMatchesCS("\\set", MatchAny): - if (TailMatchesCS("AUTOCOMMIT|ON_ERROR_STOP|QUIET|SHOW_ALL_RESULTS|" - "SINGLELINE|SINGLESTEP")) - COMPLETE_WITH_CS("on", "off"); - else if (TailMatchesCS("COMP_KEYWORD_CASE")) - COMPLETE_WITH_CS("lower", "upper", - "preserve-lower", "preserve-upper"); - else if (TailMatchesCS("ECHO")) - COMPLETE_WITH_CS("errors", "queries", "all", "none"); - else if (TailMatchesCS("ECHO_HIDDEN")) - COMPLETE_WITH_CS("noexec", "off", "on"); - else if (TailMatchesCS("HISTCONTROL")) - COMPLETE_WITH_CS("ignorespace", "ignoredups", - "ignoreboth", "none"); - else if (TailMatchesCS("ON_ERROR_ROLLBACK")) - COMPLETE_WITH_CS("on", "off", "interactive"); - else if (TailMatchesCS("SHOW_CONTEXT")) - COMPLETE_WITH_CS("never", "errors", "always"); - else if (TailMatchesCS("VERBOSITY")) - COMPLETE_WITH_CS("default", "verbose", "terse", "sqlstate"); + if (TailMatchesCS("AUTOCOMMIT|ON_ERROR_STOP|QUIET|SHOW_ALL_RESULTS|" + "SINGLELINE|SINGLESTEP")) + COMPLETE_WITH_CS("on", "off"); + else if (TailMatchesCS("COMP_KEYWORD_CASE")) + COMPLETE_WITH_CS("lower", "upper", + "preserve-lower", "preserve-upper"); + else if (TailMatchesCS("ECHO")) + COMPLETE_WITH_CS("errors", "queries", "all", "none"); + else if (TailMatchesCS("ECHO_HIDDEN")) + COMPLETE_WITH_CS("noexec", "off", "on"); + else if (TailMatchesCS("HISTCONTROL")) + COMPLETE_WITH_CS("ignorespace", "ignoredups", + "ignoreboth", "none"); + else if (TailMatchesCS("ON_ERROR_ROLLBACK")) + COMPLETE_WITH_CS("on", "off", "interactive"); + else if (TailMatchesCS("SHOW_CONTEXT")) + COMPLETE_WITH_CS("never", "errors", "always"); + else if (TailMatchesCS("VERBOSITY")) + COMPLETE_WITH_CS("default", "verbose", "terse", "sqlstate"); break; case TailMatchesCS("\\sf*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines); break; case TailMatchesCS("\\sv*"): - COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); + COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views); break; case TailMatchesCS("\\cd|\\e|\\edit|\\g|\\gx|\\i|\\include|\\ir|\\include_relative|\\o|\\out|\\s|\\w|\\write|\\lo_import"): - completion_charp = "\\"; - completion_force_quote = false; - matches = rl_completion_matches(text, complete_from_files); + completion_charp = "\\"; + completion_force_quote = false; + matches = rl_completion_matches(text, complete_from_files); break; } diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 635e6d6e21..2e4d786d45 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2802,6 +2802,7 @@ TBMSharedIterator TBMSharedIteratorState TBMStatus TBlockState +TCPattern TIDBitmap TM_FailureData TM_IndexDelete -- 2.43.5