>From 76d78dc33452294f9e536ffcf49babb58f9c7956 Mon Sep 17 00:00:00 2001
From: Kyotaro Horiguchi <horiguchi.kyotaro@lab.ntt.co.jp>
Date: Fri, 30 Oct 2015 18:18:18 +0900
Subject: [PATCH 2/2] Replace previous matching rule with regexps.

This patch simply replaces previous matching rule with regular
expressions.
---
 src/bin/psql/Makefile          |   15 +-
 src/bin/psql/tab-complete-re.h | 1160 +++++++++++++++++++++++
 src/bin/psql/tab-complete.c    | 2017 ++++++++++++----------------------------
 3 files changed, 1775 insertions(+), 1417 deletions(-)
 create mode 100644 src/bin/psql/tab-complete-re.h

diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index f1336d5..290e7b8 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,12 +23,23 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o regcomp.o regexec.o wstrncmp.o \
 	$(WIN32RES)
 
-
+CFLAGS+= -DFRONTEND
 all: psql
 
+
+regc_color.c regc_cvec.c regc_lex.c regc_locale.c regc_nfa.c regcomp.c regc_pg_locale.c rege_dfa.c regexec.c: % :$(top_srcdir)/src/backend/regex/%
+	rm -f $@ && $(LN_S) $< .
+
+wstrncmp.c: % : $(top_srcdir)/src/backend/utils/mb/%
+	rm -f $@ && $(LN_S) $< .
+
+regcomp.o regexec.o:regc_color.c regc_cvec.c regc_lex.c regc_locale.c regc_nfa.c regcomp.c regc_pg_locale.c rege_dfa.c regexec.c wstrncmp.c
+
+tab-complete.o: tab-complete.c tab-complete-re.h
+
 psql: $(OBJS) | submake-libpq submake-libpgport
 	$(CC) $(CFLAGS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
 
diff --git a/src/bin/psql/tab-complete-re.h b/src/bin/psql/tab-complete-re.h
new file mode 100644
index 0000000..e0ba4c6
--- /dev/null
+++ b/src/bin/psql/tab-complete-re.h
@@ -0,0 +1,1160 @@
+typedef enum
+{
+	RE_none,
+	RE_CREATE,
+	RE_DROP,
+	RE_ALTER_TABLE,
+	RE_ALTER,
+	RE_ALL_IN_TABLESPACE_id,
+	RE_ALL_IN_TABLESPACE_id_OWNED_BY,
+	RE_ALTER_AGGREGATEoFUNCTION,
+	RE_ALTER_AGGREGATEoFUNCTION__,
+	RE_ALTER_AGGREGATEoFUNCTION_,
+	RE_ALTER_SCHEMA_id,
+	RE_ALTER_COLLATION_id,
+	RE_ALTER_CONVERSION_id,
+	RE_ALTER_DATABASE_id,
+	RE_ALTER_EVENT_TRIGGER,
+	RE_ALTER_EVENT_TRIGGER_id,
+	RE_ALTER_EVENT_TRIGGER_id_ENABLE,
+	RE_ALTER_EXTENSION_id,
+	RE_ALTER_FOREIGN,
+	RE_ALTER_FOREIGN_DATA_WRAPPER_id,
+	RE_ALTER_FOREIGN_TABLE_id,
+	RE_ALTER_INDEX,
+	RE_ALTER_INDEX_id,
+	RE_ALTER_INDEX_id_SET,
+	RE_ALTER_INDEX_id_RESET,
+	RE_ALTER_INDEX_id_SET_,
+	RE_ALTER_INDEX_id_RESET_,
+	RE_ALTER_LANGUAGE_id,
+	RE_ALTER_LARGE_OBJECT_oid,
+	RE_ALTER_MATERIALIZED_VIEW,
+	RE_ALTER_USERoROLE_id,
+	RE_ALTER_USERoROLE_id_WITH,
+	RE_ALTER_USERoROLE_id_ENCoUNENC,
+	RE_ALTER_DEFAULT_PRIVILEGES,
+	RE_ALTER_DEFAULT_PRIVILEGES_FOR,
+	RE_ALTER_DEFAULT_PRIVILEGES_FORROLEoINSCHEMA_id,
+	RE_ALTER_DOMAIN_id,
+	RE_ALTER_DOMAIN_id_DROP,
+	RE_ALTER_DOMAIN_sth_DROPoRENAMEoVALIDATE_CONSTRAINT,
+	RE_ALTER_DOMAIN_id_RENAME,
+	RE_ALTER_DOMAIN_id_RENAME_CONSTRAINT,
+	RE_ALTER_DOMAIN_id_SET,
+	RE_ALTER_SEQUENCE_id,
+	RE_ALTER_SEQUENCE_id_NO,
+	RE_ALTER_SERVER_id,
+	RE_ALTER_SYSTEM,
+	RE_ALTER_SYSTEM_SEToRESET,
+	RE_ALTER_VIEW_id,
+	RE_ALTER_MVIEW_id,
+	RE_ALTER_POLICY_id,
+	RE_ALTER_POLICY_id_ON,
+	RE_ALTER_POLICY_id_ON_table,
+	RE_ALTER_POLICY_id_ON_table_TO,
+	RE_ALTER_POLICY_id_ON_table_USING,
+	RE_ALTER_POLICY_id_ON_table_WITH_CHECK,
+	RE_ALTER_RULE_id,
+	RE_ALTER_RULE_id_ON,
+	RE_ALTER_RULE_id_ON_id,
+	RE_ALTER_TRIGGER_id,
+	RE_ALTER_TRIGGER_id_ON,
+	RE_ALTER_TRIGGER_id_ON_id,
+	RE_ALTER_TABLE_id,
+	RE_ALTER_TABLE_id_ENABLE,
+	RE_ALTER_TABLE_id_ENABLE_REPLICAoALWAYS,
+	RE_ALTER_TABLE_id_ENABLE_RULE,
+	RE_ALTER_TABLE_id_ENABLE_kwd_RULE,
+	RE_ALTER_TABLE_id_ENABLE_TRIGGER,
+	RE_ALTER_TABLE_id_ENABLE_kwd_TRIGGER,
+	RE_ALTER_TABLE_id_INHERIT,
+	RE_ALTER_TABLE_id_NOINHERIT,
+	RE_ALTER_TABLE_id_DISABLE,
+	RE_ALTER_TABLE_id_DISABLE_RULE,
+	RE_ALTER_TABLE_id_DISABLE_TRIGGER,
+	RE_ALTER_TABLE_id_DISABLE_ROW_LEVEL_SECURITY,
+	RE_ALTER_TABLE_id_ALTER,
+	RE_ALTER_TABLE_id_RENAME,
+	RE_ALTER_TABLE_id_ALTERoRENAME_COLUMN,
+	RE_ALTER_TABLE_id_RENAME_negCONSTRAINToTO,
+	RE_ALTER_TABLE_id_RENAME_COLUMNoCONSTRAINT_negTO,
+	RE_ALTER_TABLE_id_ALToDROPoRENoVALIDATE_CONSTR,
+	RE_ALTER_TABLE_id_RENAMEoRENCOLoRENCONST_id,
+	RE_ALTER_TABLE_id_DROP,
+	RE_ALTER_TABLE_id_DROP_COLUMN,
+	RE_ALTER_TABLE_id_ALTER_oCOLUMN_id,
+	RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET,
+	RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET_,
+	RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET_STORAGE,
+	RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_DROP,
+	RE_ALTER_TABLE_id_CLUSTER,
+	RE_ALTER_TABLE_id_CLUSTER_ON,
+	RE_ALTER_TABLE_id_SET,
+	RE_ALTER_TABLE_id_SET_TABLESPACE,
+	RE_ALTER_TABLE_id_SET_WITHOUT,
+	RE_ALTER_TABLE_id_RESET,
+	RE_ALTER_TABLE_id_RESET_,
+	RE_ALTER_TABLE_id_REPLICA_IDENTITY_USING_INDEX,
+	RE_ALTER_TABLE_id_REPLICA_IDENTITY_USING,
+	RE_ALTER_TABLE_id_REPLICA_IDENTITY,
+	RE_ALTER_TABLE_id_REPLICA,
+	RE_ALTER_TABLESPACE_id,
+	RE_ALTER_TABLESPACE_id_SEToRESET,
+	RE_ALTER_TABLESPACE_id_SEToRESET_,
+	RE_ALTER_TEXT_SEARCH,
+	RE_ALTER_TEXT_SEARCH_TEMPLATEoPARSER_id,
+	RE_ALTER_TEXT_SEARCH_DICTIONARY_id,
+	RE_ALTER_TEXT_SEARCH_CONFIGURATION_id,
+	RE_ALTER_TYPE_id,
+	RE_ALTER_TYPE_id_ADD,
+	RE_ALTER_TYPE_id_RENAME,
+	RE_ALTER_TYPE_id_RENAME_ATTRIBUTE_id,
+	RE_ALTER_TYPE_id_ALToDROPoREN_ATTRIBUTE,
+	RE_ALTER_TYPE_id_ALTER_ATTRIBUTE_id,
+	RE_ALTER_GROUP_id,
+	RE_ALTER_GROUP_id_ADDoDROP,
+	RE_ALTER_GROUP_id_ADDoDROP_USER,
+	RE_BEGINoENDoABORT,
+	RE_COMMIT,
+	RE_RELEASE,
+	RE_ROLLBACK,
+	RE_CLUSTER,
+	RE_CLUSTER_VERBOSE,
+	RE_CLUSTER_negONoVERBOSE,
+	RE_CLUSTER_VERBOSE_id,
+	RE_CLUSTER_id_USING,
+	RE_CLUSTER_VERBOSE_id_USING,
+	RE_COMMENT,
+	RE_COMMENT_ON,
+	RE_COMMENT_ON_FOREIGN,
+	RE_COMMENT_ON_TEXT_SEARCH,
+	RE_COMMENT_ON_CONSTRAINT,
+	RE_COMMENT_ON_CONSTRAINT_id,
+	RE_COMMENT_ON_CONSTRAINT_id_ON,
+	RE_COMMENT_ON_MATERIALIZED_VIEW,
+	RE_COMMENT_ON_EVENT_TRIGGER,
+	RE_COMMENT_ON_any_negIS,
+	RE_COPY_oBINARY,
+	RE_COPY_oBINARY_id,
+	RE_COPY_oBINARY_id_FROMoTO,
+	RE_COPY_oBINARY_id_FROMoTO_any,
+	RE_COPY_any_FROMoTO_any_CSV,
+	RE_CREATE_DATABASE_id,
+	RE_CREATE_DATABASE_id_TEMPLATE,
+	RE_CREATE_EXTENSION,
+	RE_CREATE_EXTENSION_id,
+	RE_CREATE_EXTENSION_id_VERSION,
+	RE_CREATE_FOREIGN,
+	RE_CREATE_FOREIGN_DATA_WRAPPER_id,
+	RE_CREATE_UNIQUE,
+	RE_CREATE_oUNIQUE_INDEX,
+	RE_INDEX_oname_CONCURRENTLY_ON,
+	RE_INDEX_oname_CONCURRENTLY,
+	RE_CREATE_oUNIQUE_INDEX_name,
+	RE_INDEX_oname_CONCURRENTLY_ON_id,
+	RE_INDEX_oname_CONCURRENTLY_ON_id_,
+	RE_ON_id_USING_kwd_,
+	RE_ON_id_USING,
+	RE_CREATE_INDEX_any_ON_id_USING_kwd,
+	RE_CREATE_POLICY_id,
+	RE_CREATE_POLICY_id_ON,
+	RE_CREATE_POLICY_id_ON_id,
+	RE_CREATE_POLICY_id_ON_id_FOR,
+	RE_CREATE_POLICY_id_ON_id_FOR_INSERT,
+	RE_CREATE_POLICY_id_ON_id_FOR_UPDATE,
+	RE_CREATE_POLICY_id_ON_id_FOR_SELoDEL,
+	RE_CREATE_POLICY_id_ON_id_TO,
+	RE_CREATE_POLICY_id_ON_id_USING,
+	RE_CREATE_RULE_id,
+	RE_CREATE_RULE_id_AS,
+	RE_CREATE_RULE_id_AS_ON,
+	RE_CREATE_RULE_id_AS_ON_event,
+	RE_CREATE_RULE_id_AS_ON_event_TO,
+	RE_CREATE_oTEMP_SEQUENCE_oINE_id,
+	RE_CREATE_oTEMP_SEQUENCE_oINE_id_any_NO,
+	RE_CREATE_SERVER_id,
+	RE_CREATE_TEMP,
+	RE_CREATE_UNLOGGED,
+	RE_CREATE_TABLESPACE_id,
+	RE_CREATE_TABLESPACE_id_OWNER_id,
+	RE_CREATE_TEXT_SEARCH,
+	RE_CREATE_TEXT_SEARCH_CONFIGURATION_id,
+	RE_CREATE_TRIGGER_id,
+	RE_CREATE_TRIGGER_id_BEFoAFT,
+	RE_CREATE_TRIGGER_id_INSTEAD_OF,
+	RE_CREATE_TRIGGER_id_BEFoAFToINSOF_events,
+	RE_CREATE_TRIGGER_id_BEFoAFToINSOF_events_ON,
+	RE_CREATE_TRIGGER_id_any_EXECUTE,
+	RE_CREATE_USERoROLEoGROUP_id,
+	RE_CREATE_USERoROLEoGROUP_id_WITH,
+	RE_CREATE_USERoROLEoGROUP_id_ENCoUNENC,
+	RE_CREATE_USERoROLEoGROUP_id_IN,
+	RE_CREATE_VIEW_id,
+	RE_CREATE_VIEW_id_AS,
+	RE_CREATE_MATERIALIZED,
+	RE_CREATE_MATVIEW_id,
+	RE_CREATE_MATVIEW_id_any_AS,
+	RE_CREATE_EVENT,
+	RE_CREATE_EVENT_TRIGGER_id,
+	RE_CREATE_EVENT_TRIGGER_id_ON,
+	RE_DECLARE_id,
+	RE_DECLARE_id_oBIN_oINSEN_oNOSCR_CURSOR,
+	RE_DELETE,
+	RE_DELETE_FROM,
+	RE_DELETE_FROM_id,
+	RE_DISCARD,
+	RE_DO,
+	RE_DROP_AGGREGATE_id,
+	RE_DROP_obj_1,
+	RE_DROP_obj_2,
+	RE_DROP_obj_3,
+	RE_DROP_FUNCTION_id,
+	RE_DROP_FOREIGN,
+	RE_DROP_MATERIALIZED,
+	RE_DROP_MATERIALIZED_VIEW,
+	RE_DROP_AGGoFUNC_id_,
+	RE_DROP_OWNED,
+	RE_DROP_OWNED_BY,
+	RE_DROP_TEXT_SEARARCH,
+	RE_DROP_TRIGGER_id,
+	RE_DROP_TRIGGER_id_ON,
+	RE_DROP_TRIGGER_id_ON_id,
+	RE_DROP_EVENT,
+	RE_DROP_EVENT_TRIGGER,
+	RE_DROP_POLICY,
+	RE_DROP_POLICY_id,
+	RE_DROP_POLICY_id_ON,
+	RE_DROP_RULE_id,
+	RE_DROP_RULE_id_ON,
+	RE_DROP_RULE_id_ON_id,
+	RE_EXECUTE,
+	RE_EXPLAIN,
+	RE_EXPLAIN_ANALYZE,
+	RE_EXPLAIN_oANALYZE_VERBOSE,
+	RE_FETCHoMOVE,
+	RE_FETCHoMOVE_id,
+	RE_FETCHoMOVE_any_any,
+	RE_negCREATE_FOREIGN_DATA_WRAPPER,
+	RE_negCREATE_FOREIGN_TABLE,
+	RE_FOREIGN_SERVER,
+	RE_GRANToREVOKE,
+	RE_GRANToREVOKE_kwd,
+	RE_GRANToREVOKE_id,
+	RE_GRANToREVOKE_kwd_ON,
+	RE_GRANToREVOKE_kwd_ON_ALL,
+	RE_GRANToREVOKE_kwd_ON_FOREIGN,
+	RE_GRANToREVOKE_kwd_ON_any,
+	RE_GRANToREVOKE_kwd_ON_ALL_any_IN_SCHEMA_id,
+	RE_GRANToREVOKE_kwd_ON_FDW_id,
+	RE_GRANToREVOKE_kwd_ON_FOREIGN_SERVER_id,
+	RE_GRANToREVOKE_any_TO,
+	RE_GRANToREVOKE_kwd_ON_kwd_id,
+	RE_GRANToREVOKE_kwd_TO,
+	RE_FROM_any_GROUP,
+	RE_IMPORT,
+	RE_IMPORT_FOREIGN,
+	RE_INSERT,
+	RE_INSERT_INTO,
+	RE_INSERT_INTO_id_,
+	RE_INSERT_INTO_id,
+	RE_INSERT_INTO_id__,
+	RE_negDEFAULT_VALUES,
+	RE_LOCK,
+	RE_LOCK_TABLE,
+	RE_LOCK_oTABLE_id,
+	RE_LOCK_oTABLE_id_IN,
+	RE_NOTIFY,
+	RE_OPTIONS,
+	RE_OWNER_TO,
+	RE_FROM_any_ORDER,
+	RE_FROM_any_ORDER_BY,
+	RE_PREPARE_any_AS,
+	RE_REASSIGN,
+	RE_REASSIGN_OWNED,
+	RE_REASSIGN_OWNED_BY,
+	RE_REASSIGN_OWNED_BY_id,
+	RE_REASSIGN_OWNED_BY_id_TO,
+	RE_REFRESH,
+	RE_REFRESH_MATERIALIZED,
+	RE_REFRESH_MATERIALIZED_VIEW,
+	RE_REFRESH_MATERIALIZED_VIEW_CONC,
+	RE_REFRESH_MATERIALIZED_VIEW_id,
+	RE_REFRESH_MATERIALIZED_VIEW_CONC_id,
+	RE_REFRESH_MATERIALIZED_VIEW_id_WITH,
+	RE_REFRESH_MATERIALIZED_VIEW_CONC_id_WITH,
+	RE_REFRESH_MATERIALIZED_VIEW_id_WITH_NO,
+	RE_REINDEX,
+	RE_REINDEX_kwd,
+	RE_SECURITY,
+	RE_SECURITY_LABEL,
+	RE_SECURITY_LABEL_FOR_id,
+	RE_SECURITY_LABEL_oFORname_ON,
+	RE_SECURITY_LABEL_ON_kwd_id,
+	RE_SEToRESET,
+	RE_SHOW,
+	RE_SET_TRANSACTIONs,
+	RE_SET_TRANSACTIONs_ISOLATION,
+	RE_SET_TRANSACTIONs_ISOLATION_LEVEL,
+	RE_SET_TRANSACTIONs_ISOLATION_LEVEL_READ,
+	RE_SET_TRANSACTIONs_ISOLATION_LEVEL_REPEATABLE,
+	RE_SET_TRANSACTIONs_READ,
+	RE_SET_CONSTRAINTS,
+	RE_SET_CONSTRAINTS_id,
+	RE_SET_ROLE,
+	RE_SET_SESSION,
+	RE_SET_SESSION_AUTH,
+	RE_RESET_SESSION,
+	RE_SET_var,
+	RE_SET_var_TOoEQ,
+	RE_START,
+	RE_TABLE,
+	RE_any_TABLESAMPLE,
+	RE_any_TABLESAMPLE_id,
+	RE_TRUNCATE,
+	RE_UNLISTEN,
+	RE_any_UPDATE,
+	RE_any_UPDATE_id,
+	RE_any_id_SET,
+	RE_any_UPDATE_id_SET_id,
+	RE_CRToALToDRP_USER_MAPPING,
+	RE_CREATE_USER_MAPPING_FOR,
+	RE_ALToDRP_USER_MAPPING_FOR,
+	RE_CRToALToDRP_USER_MAPPING_FOR_id,
+	RE_VACUUM,
+	RE_VACUUM_FULLoFREEZE,
+	RE_VACUUM_FULLoFREEZE_ANALYZE,
+	RE_VACUUM_FULLoFREEZE_VERBOSE,
+	RE_VACUUM_VERBOSE,
+	RE_VACUUM_ANALYZE,
+	RE_any_ANLVRBoVRBANL,
+	RE_WITH,
+	RE_any_ANALYZE,
+	RE_any_id_WHERE,
+	RE_COPY_id_FROM,
+	RE_any_JOIN,
+
+/* metacommands */
+	RE_meta_question,
+	RE_meta_CONNECT,
+	RE_meta_CONNECT_word,
+	RE_meta_da,
+	RE_meta_db,
+	RE_meta_dD,
+	RE_meta_des,
+	RE_meta_deu,
+	RE_meta_dew,
+	RE_meta_df,
+	RE_meta_dFd,
+	RE_meta_dFp,
+	RE_meta_dFt,
+	RE_meta_dF,
+	RE_meta_di,
+	RE_meta_dL,
+	RE_meta_dn,
+	RE_meta_dpOz,
+	RE_meta_ds,
+	RE_meta_dt,
+	RE_meta_dT,
+	RE_meta_duOdg,
+	RE_meta_dv,
+	RE_meta_dx,
+	RE_meta_dm,
+	RE_meta_dE,
+	RE_meta_dy,
+	RE_meta_d,
+	RE_meta_ef,
+	RE_meta_ev,
+	RE_meta_encoding,
+	RE_meta_h,
+	RE_meta_password,
+	RE_meta_pset,
+	RE_meta_pset_id,
+	RE_meta_unset,
+	RE_meta_set,
+	RE_meta_set_id,
+	RE_meta_sf,
+	RE_meta_sv,
+	RE_meta_FILECMDS,
+	RE_AnySingleWord,
+	RE_NUM
+} patterns;
+
+
+#define WB  "[\\t\\n@$><=;|&{\\(\\) ]"				/* WORD BREAKS */
+#define NWB "[^\\t\\n@$><=;|&{\\(\\) ]"				/* ^WORD BREAKS */
+#define PB  "^(?:.*;)?\\s*"			/* bind to the beginning of the line */
+#define PM  "^(?:.*"NWB WB")?\\s*"					/* floating head */
+#define ID  NWB"+"									/* identifier */
+#define KWD "\\w+"									/* any keywords */
+typedef struct _comp_def
+{
+	patterns pat_id;		/* for sanity check */
+	char *pat;				/* pattern */
+	int cflags;
+} comp_def;
+
+static comp_def redef[] =
+{
+	{RE_none,
+	 PB"\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE,
+	 PM"CREATE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP,
+	 PB"DROP\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_TABLE,
+	 PM"ALTER\\s+TABLE\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER,
+	 PB"ALTER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALL_IN_TABLESPACE_id,
+	 PM"ALL\\s+IN\\s+TABLESPACE\\s+"ID"\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALL_IN_TABLESPACE_id_OWNED_BY,
+	 PM"ALL\\s+IN\\s+TABLESPACE\\s+"ID"\\s+OWNED\\s+BY\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_AGGREGATEoFUNCTION,
+	 PM"ALTER\\s+(AGGREGATE|FUNCTION)\\s+"ID"\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_AGGREGATEoFUNCTION__,
+	 PM"ALTER\\s+(?:AGGREGATE|FUNCTION)\\s\\w+\\s*\\(.*\\)\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_AGGREGATEoFUNCTION_,
+	 PM"ALTER\\s+(?:AGGREGATE|FUNCTION)\\s+("ID")\\s*\\(\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_SCHEMA_id,
+	 PM"ALTER\\s+SCHEMA\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_COLLATION_id,
+	 PM"ALTER\\s+COLLATION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_CONVERSION_id,
+	 PM"ALTER\\s+CONVERSION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DATABASE_id,
+	 PM"ALTER\\s+DATABASE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_EVENT_TRIGGER,
+	 PM"ALTER\\s+EVENT\\s+TRIGGER\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_EVENT_TRIGGER_id,
+	 PM"ALTER\\s+EVENT\\s+TRIGGER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_EVENT_TRIGGER_id_ENABLE,
+	 PM"ALTER\\s+EVENT\\s+TRIGGER\\s+"ID"\\s+ENABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_EXTENSION_id,
+	 PM"ALTER\\s+EXTENSION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_FOREIGN,
+	 PM"ALTER\\s+FOREIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_FOREIGN_DATA_WRAPPER_id,
+	 PM"ALTER\\s+FOREIGN\\s+DATA\\s+WRAPPER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_FOREIGN_TABLE_id,
+	 PM"ALTER\\s+FOREIGN\\s+TABLE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_INDEX,
+	 PM"ALTER\\s+INDEX\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_INDEX_id,
+	 PM"ALTER\\s+INDEX\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_INDEX_id_SET,
+	 PM"ALTER\\s+INDEX\\s+"ID"\\s+SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_INDEX_id_RESET,
+	 PM"ALTER\\s+INDEX\\s+"ID"\\s+RESET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_INDEX_id_SET_,
+	 PM"ALTER\\s+INDEX\\s+"ID"\\s+SET\\s*\\(\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_INDEX_id_RESET_,
+	 PM"ALTER\\s+INDEX\\s+"ID"\\s+RESET\\s*\\(\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_LANGUAGE_id,
+	 PM"ALTER\\s+LANGUAGE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_LARGE_OBJECT_oid,
+	 PM"ALTER\\s+LARGE\\s+OBJECT\\s+\\w+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_MATERIALIZED_VIEW,
+	 PM"ALTER\\s+MATERIALIZED\\s+VIEW\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_USERoROLE_id,
+	 PM"ALTER\\s+(?!USER\\s+MAPPING)(ROLE|USER)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_USERoROLE_id_WITH,
+	 PM"ALTER\\s+(?!USER\\s+MAPPING)(ROLE|USER)\\s+"ID"\\s+WITH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_USERoROLE_id_ENCoUNENC,
+	 PM"ALTER\\s+(?!USER\\s+MAPPING)(ROLE|USER)\\s+"ID"\\s+(UN)?ENCRYPTED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DEFAULT_PRIVILEGES,
+	 PM"ALTER\\s+DEFAULT\\s+PRIVILEGES\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DEFAULT_PRIVILEGES_FOR,
+	 PM"ALTER\\s+DEFAULT\\s+PRIVILEGES\\s+FOR\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DEFAULT_PRIVILEGES_FORROLEoINSCHEMA_id,
+	 PM"ALTER\\s+DEFAULT\\s+PRIVILEGES\\s+(?:FOR\\s+ROLE|IN\\s+SCHEMA)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DOMAIN_id,
+	 PM"ALTER\\s+DOMAIN\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DOMAIN_id_DROP,
+	 PM"ALTER\\s+DOMAIN\\s+"ID"\\s+DROP\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DOMAIN_sth_DROPoRENAMEoVALIDATE_CONSTRAINT,
+	 PM"ALTER\\s+DOMAIN\\s+("ID")\\s+(?:DROP|RENAME|VALIDATE)\\s+CONSTRAINT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DOMAIN_id_RENAME,
+	 PM"ALTER\\s+DOMAIN\\s+"ID"\\s+RENAME\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DOMAIN_id_RENAME_CONSTRAINT,
+	 PM"ALTER\\s+DOMAIN\\s+"ID"\\s+RENAME\\s+CONSTRAINT\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_DOMAIN_id_SET,
+	 PM"ALTER\\s+DOMAIN\\s+"ID"\\s+SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_SEQUENCE_id,
+	 PM"ALTER\\s+SEQUENCE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_SEQUENCE_id_NO,
+	 PM"ALTER\\s+SEQUENCE\\s+"ID"\\s+NO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALTER_SERVER_id,
+	 PM"ALTER\\s+SERVER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_SYSTEM,
+	 PM"ALTER\\s+SYSTEM\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_SYSTEM_SEToRESET,
+	 PM"ALTER\\s+SYSTEM\\s+(?:RE)?SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_VIEW_id,
+	 PM"ALTER\\s+VIEW\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_MVIEW_id,
+	 PM"ALTER\\s+MATERIALIZED\\s+VIEW\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_POLICY_id,
+	 PM"ALTER\\s+POLICY\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_POLICY_id_ON,
+	 PM"ALTER\\s+POLICY\\s+"ID"\\s+ON\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_POLICY_id_ON_table,
+	 PM"ALTER\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_POLICY_id_ON_table_TO,
+	 PM"ALTER\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+TO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_POLICY_id_ON_table_USING,
+	 PM"ALTER\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+USING\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_POLICY_id_ON_table_WITH_CHECK,
+	 PM"ALTER\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+WITH\\s+CHECK\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_RULE_id,
+	 PM"ALTER\\s+RULE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_RULE_id_ON,
+	 PM"ALTER\\s+RULE\\s+("ID")\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_RULE_id_ON_id,
+	 PM"ALTER\\s+RULE\\s+"ID"\\s+ON\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TRIGGER_id,
+	 PM"ALTER\\s+TRIGGER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TRIGGER_id_ON,
+	 PM"ALTER\\s+TRIGGER\\s+("ID")\\s+ON\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TRIGGER_id_ON_id,
+	 PM"ALTER\\s+TRIGGER\\s+("ID")\\s+ON\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ENABLE,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ENABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ENABLE_REPLICAoALWAYS,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ENABLE\\s+(?:REPLICA|ALWAYS)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ENABLE_RULE,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ENABLE\\s+RULE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ENABLE_kwd_RULE,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ENABLE\\s+\\w+\\s+RULE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ENABLE_TRIGGER,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ENABLE\\s+TRIGGER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ENABLE_kwd_TRIGGER,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ENABLE\\s+\\w+\\s+TRIGGER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_INHERIT,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+INHERIT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_NOINHERIT,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+NO\\s+INHERIT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_DISABLE,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+DISABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_DISABLE_RULE,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+DISABLE\\s+RULE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_DISABLE_TRIGGER,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+DISABLE\\s+TRIGGER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_DISABLE_ROW_LEVEL_SECURITY,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+DISABLE\\s+ROW\\s+LEVEL\\s+SECURITY\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTER,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+ALTER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_RENAME,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+RENAME\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTERoRENAME_COLUMN,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+(?:ALTER|RENAME)\\s+COLUMN\\s+\\w*$", REG_ADVANCED|REG_ICASE},	
+ 	{RE_ALTER_TABLE_id_RENAME_negCONSTRAINToTO,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+RENAME\\s+(?!CONSTRAINT|TO)"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},	
+ 	{RE_ALTER_TABLE_id_RENAME_COLUMNoCONSTRAINT_negTO,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+RENAME\\s+(?:COLUMN|CONSTRAINT)\\s+(?!TO)"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},	
+ 	{RE_ALTER_TABLE_id_ALToDROPoRENoVALIDATE_CONSTR,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+(?:ALTER|DROP|RENAME|VALIDATE)\\s+CONSTRAINT\\s+\\w*$", REG_ADVANCED|REG_ICASE},	
+ 	{RE_ALTER_TABLE_id_RENAMEoRENCOLoRENCONST_id,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+RENAME\\s+(?:COLUMN\\s+|CONSTRAINT\\s+)?"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_DROP,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+DROP\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_DROP_COLUMN,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+DROP\\s+COLUMN\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTER_oCOLUMN_id,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+ALTER\\s+(?:(?:COLUMN\\s+"ID")|(?!COLUMN\\s+)"ID")\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+ALTER\\s+(?:(?:COLUMN\\s+"ID")|(?!COLUMN\\s+)"ID")\\s+SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET_,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+ALTER\\s+(?:(?:COLUMN\\s+"ID")|(?!COLUMN\\s+)"ID")\\s+SET\\s+\\(\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET_STORAGE,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+ALTER\\s+(?:(?:COLUMN\\s+"ID")|(?!COLUMN\\s+)"ID")\\s+SET\\s+STORAGE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_DROP,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+ALTER\\s+(?:(?:COLUMN\\s+"ID")|(?!COLUMN\\s+)"ID")\\s+DROP\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_CLUSTER,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+CLUSTER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_CLUSTER_ON,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+CLUSTER\\s+ON\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_SET,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_SET_TABLESPACE,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+SET\\s+TABLESPACE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_SET_WITHOUT,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+SET\\s+WITHOUT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_RESET,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+RESET\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_RESET_,
+	 PM"ALTER\\s+TABLE\\s+"ID"\\s+RESET\\s*\\(\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_REPLICA_IDENTITY_USING_INDEX,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+REPLICA\\s+IDENTITY\\s+USING\\s+INDEX\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_REPLICA_IDENTITY_USING,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+REPLICA\\s+IDENTITY\\s+USING\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_REPLICA_IDENTITY,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+REPLICA\\s+IDENTITY\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLE_id_REPLICA,
+	 PM"ALTER\\s+TABLE\\s+("ID")\\s+REPLICA\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLESPACE_id,
+	 PM"ALTER\\s+TABLESPACE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLESPACE_id_SEToRESET,
+	 PM"ALTER\\s+TABLESPACE\\s+"ID"\\s+(?:RE)?SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TABLESPACE_id_SEToRESET_,
+	 PM"ALTER\\s+TABLESPACE\\s+"ID"\\s+(?:RE)?SET\\s*\\(\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TEXT_SEARCH,
+	 PM"ALTER\\s+TEXT\\s+SEARCH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TEXT_SEARCH_TEMPLATEoPARSER_id,
+	 PM"ALTER\\s+TEXT\\s+SEARCH\\s+(?:TEMPLATE|PARSER)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TEXT_SEARCH_DICTIONARY_id,
+	 PM"ALTER\\s+TEXT\\s+SEARCH\\s+DICTIONARY\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TEXT_SEARCH_CONFIGURATION_id,
+	 PM"ALTER\\s+TEXT\\s+SEARCH\\s+CONFIGURATION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TYPE_id,
+	 PM"ALTER\\s+TYPE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TYPE_id_ADD,
+	 PM"ALTER\\s+TYPE\\s+"ID"\\s+ADD\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TYPE_id_RENAME,
+	 PM"ALTER\\s+TYPE\\s+"ID"\\s+RENAME\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TYPE_id_RENAME_ATTRIBUTE_id,
+	 PM"ALTER\\s+TYPE\\s+"ID"\\s+RENAME\\s+ATTRIBUTE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TYPE_id_ALToDROPoREN_ATTRIBUTE,
+	 PM"ALTER\\s+TYPE\\s+("ID")\\s+(?:ALTER|DROP|RENAME)\\s+ATTRIBUTE\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_TYPE_id_ALTER_ATTRIBUTE_id,
+	 PM"ALTER\\s+TYPE\\s+("ID")\\s+ALTER\\s+ATTRIBUTE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_GROUP_id,
+	 PM"ALTER\\s+GROUP\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_GROUP_id_ADDoDROP,
+	 PM"ALTER\\s+GROUP\\s+"ID"\\s+(?:ADD|DROP)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ALTER_GROUP_id_ADDoDROP_USER,
+	 PM"ALTER\\s+GROUP\\s+"ID"\\s+(?:ADD|DROP)\\s+USER\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_BEGINoENDoABORT,
+	 PM"(?:BEGIN|END|ABORT)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMIT,
+	 PM"COMMIT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_RELEASE,
+	 PM"RELEASE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ROLLBACK,
+	 PM"ROLLBACK\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CLUSTER,
+	 PM"CLUSTER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CLUSTER_VERBOSE,
+	 PM"CLUSTER\\s+VERBOSE\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CLUSTER_negONoVERBOSE,
+	 PM"CLUSTER\\s+(?!ON|VERBOSE)"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CLUSTER_VERBOSE_id,
+	 PM"CLUSTER\\s+VERBOSE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CLUSTER_id_USING,
+	 PM"CLUSTER\\s+("ID")\\s+USING\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CLUSTER_VERBOSE_id_USING,
+	 PM"CLUSTER\\s+VERBOSE\\s+("ID")\\s+USING\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT,
+	 PM"COMMENT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON,
+	 PM"COMMENT\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_FOREIGN,
+	 PM"COMMENT\\s+ON\\s+FOREIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_TEXT_SEARCH,
+	 PM"COMMENT\\s+ON\\s+TEXT\\s+SEARCH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_CONSTRAINT,
+	 PM"COMMENT\\s+ON\\s+CONSTRAINT\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_CONSTRAINT_id,
+	 PM"COMMENT\\s+ON\\s+CONSTRAINT\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_CONSTRAINT_id_ON,
+	 PM"COMMENT\\s+ON\\s+CONSTRAINT\\s+("ID")\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_MATERIALIZED_VIEW,
+	 PM"COMMENT\\s+ON\\s+MATERIALIZED\\s+VIEW\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_EVENT_TRIGGER,
+	 PM"COMMENT\\s+ON\\s+EVENT\\s+TRIGGER\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COMMENT_ON_any_negIS,
+	 PM"COMMENT\\s+ON\\s+.*\\s+(?!IS)"ID"\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COPY_oBINARY,
+	 PM"(?:COPY\\s+(?:BINARY\\s+)?|\\\\COPY\\s+)[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COPY_oBINARY_id,
+	 PM"(?:COPY\\s+(?:BINARY\\s+)?|\\\\COPY\\s+)"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COPY_oBINARY_id_FROMoTO,
+	 PM"(?:COPY\\s+(?:BINARY\\s+)?|\\\\COPY\\s+)"ID"\\s+(?:FROM|TO)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COPY_oBINARY_id_FROMoTO_any,
+	 PM"(?:COPY\\s+(?:BINARY\\s+)?|\\\\COPY\\s+)"ID"\\s+(?:FROM|TO)\\s+.*\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_COPY_any_FROMoTO_any_CSV,
+	 PM"COPY\\s+.*\\s+(?:FROM|TO).*(?:WITH\\s+)?CSV\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_DATABASE_id,
+	 PM"CREATE\\s+DATABASE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_DATABASE_id_TEMPLATE,
+	 PM"CREATE\\s+DATABASE\\s+"ID"\\s+TEMPLATE\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_EXTENSION,
+	 PM"CREATE\\s+EXTENSION\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_EXTENSION_id,
+	 PM"CREATE\\s+EXTENSION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_EXTENSION_id_VERSION,
+	 PM"CREATE\\s+EXTENSION\\s+("ID")\\s+VERSION\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_FOREIGN,
+	 PM"CREATE\\s+FOREIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_FOREIGN_DATA_WRAPPER_id,
+	 PM"CREATE\\s+FOREIGN\\s+DATA\\s+WRAPPER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_UNIQUE,
+	 PM"CREATE\\s+UNIQUE"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_oUNIQUE_INDEX,
+	 PM"CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_INDEX_oname_CONCURRENTLY_ON,
+	 PM"INDEX\\s+(?:"ID"\\s+)?CONCURRENTLY\\s+ON\\s+"NWB"*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_INDEX_oname_CONCURRENTLY,
+	 PM"INDEX\\s+(?:"ID"\\s+)?CONCURRENTLY\\s+"NWB"*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_oUNIQUE_INDEX_name,
+	 PM"CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+"ID"\\s+"NWB"*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_INDEX_oname_CONCURRENTLY_ON_id,
+	 PM"INDEX\\s+(?:"ID"\\s+)?CONCURRENTLY\\s+ON\\s+"ID"\\s+"NWB"*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_INDEX_oname_CONCURRENTLY_ON_id_,
+	 PM"INDEX\\s+(?:"ID"\\s+)?CONCURRENTLY\\s+ON\\s+"ID"\\s*\\(\\s*"NWB"*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_ON_id_USING_kwd_,
+	 PM"ON\\s+"ID"\\s+USING\\s+"KWD"\\s*\\(\\s*"NWB"*$", REG_ADVANCED|REG_ICASE},
+	{RE_ON_id_USING,
+	 PM"ON\\s+"ID"\\s+USING\\s+"NWB"*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_INDEX_any_ON_id_USING_kwd,
+	 PB"CREATE\\s+INDEX\\s+(?:.+\\s+)?ON\\s+"ID"\\s+USING\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	
+ 	{RE_CREATE_POLICY_id,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id_FOR,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+FOR\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id_FOR_INSERT,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+FOR\\s+INSERT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id_FOR_UPDATE,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+FOR\\s+UPDATE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id_FOR_SELoDEL,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+FOR\\s+(?:SELECT|DELETE)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id_TO,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+TO\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_POLICY_id_ON_id_USING,
+	 PM"CREATE\\s+POLICY\\s+"ID"\\s+ON\\s+"ID"\\s+USING\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_RULE_id,
+	 PM"CREATE\\s+RULE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_RULE_id_AS,
+	 PM"CREATE\\s+RULE\\s+"ID"\\s+AS\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_RULE_id_AS_ON,
+	 PM"CREATE\\s+RULE\\s+"ID"\\s+AS\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_RULE_id_AS_ON_event,
+	 PM"CREATE\\s+RULE\\s+"ID"\\s+AS\\s+ON\\s+(?:SELECT|INSERT|UPDATE|DELETE)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_RULE_id_AS_ON_event_TO,
+	 PM"CREATE\\s+RULE\\s+"ID"\\s+AS\\s+ON\\s+(?:SELECT|INSERT|UPDATE|DELETE)\\s+TO\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_oTEMP_SEQUENCE_oINE_id,
+	 PM"CREATE\\s+(?:TEMP(?:ORARY)?\\s+)?SEQUENCE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_oTEMP_SEQUENCE_oINE_id_any_NO,
+	 PM"CREATE\\s+(?:TEMP(?:ORARY)?\\s+)?SEQUENCE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?"ID"\\s+(?:.*\\s+)?NO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+ 	{RE_CREATE_SERVER_id,
+	 PM"CREATE\\s+SERVER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TEMP,
+	 PM"CREATE\\s+TEMP(ORARY)?\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_UNLOGGED,
+	 PM"CREATE\\s+UNLOGGED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TABLESPACE_id,
+	 PM"CREATE\\s+TABLESPACE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TABLESPACE_id_OWNER_id,
+	 PM"CREATE\\s+TABLESPACE\\s+"ID"\\s+OWNER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TEXT_SEARCH,
+	 PM"CREATE\\s+TEXT\\s+SEARCH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TEXT_SEARCH_CONFIGURATION_id,
+	 PM"CREATE\\s+TEXT\\s+SEARCH\\s+CONFIGURATION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TRIGGER_id,
+	 PM"CREATE\\s+(?:CONSTRAINT\\s+)?TRIGGER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TRIGGER_id_BEFoAFT,
+	 PM"CREATE\\s+(?:CONSTRAINT\\s+)?TRIGGER\\s+"ID"\\s+(?:BEFORE|AFTER)\\s+(?:"ID"\\s+OR\\s+)*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TRIGGER_id_INSTEAD_OF,
+	 PM"CREATE\\s+(?:CONSTRAINT\\s+)?TRIGGER\\s+"ID"\\s+INSTEAD\\s+OF\\s+(?:"ID"\\s+OR\\s+)*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TRIGGER_id_BEFoAFToINSOF_events,
+	 PM"CREATE\\s+(?:CONSTRAINT\\s+)?TRIGGER\\s+"ID"\\s+(?:BEFORE|AFTER|INSTEAD\\s+OF)\\s+"ID"(?:\\s+OR\\s+"ID")*\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TRIGGER_id_BEFoAFToINSOF_events_ON,
+	 PM"CREATE\\s+(?:CONSTRAINT\\s+)?TRIGGER\\s+"ID"\\s+(?:BEFORE|AFTER|INSTEAD\\s+OF)\\s+"ID"(?:\\s+OR\\s+"ID")*\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_TRIGGER_id_any_EXECUTE,
+	 PM"CREATE\\s+(?:CONSTRAINT\\s+)?TRIGGER\\s+"ID"\\s+.*\\s+EXECUTE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_USERoROLEoGROUP_id,
+	 PM"CREATE\\s+(?:USER(?!\\s+MAPPING)|ROLE|GROUP)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_USERoROLEoGROUP_id_WITH,
+	 PM"CREATE\\s+(?:USER(?!\\s+MAPPING)|ROLE|GROUP)\\s+"ID"\\s+WITH\\s+(?:"ID"\\s+)*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_USERoROLEoGROUP_id_ENCoUNENC,
+	 PM"CREATE\\s+(?:USER(?!\\s+MAPPING)|ROLE|GROUP)\\s+"ID"\\s+(?:UN)?ENCRYPTED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_USERoROLEoGROUP_id_IN,
+	 PM"CREATE\\s+(?:USER(?!\\s+MAPPING)|ROLE|GROUP)\\s+"ID"\\s+IN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_VIEW_id,
+	 PM"CREATE\\s+(?:OR\\s+REPLACE\\s+)?(?:TEMP(?:ORARY)?\\s+)?(?:RECURSIVE\\s+)?VIEW\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_VIEW_id_AS,
+	 PM"CREATE\\s+(?:OR\\s+REPLACE\\s+)?(?:TEMP(?:ORARY)?\\s+)?(?:RECURSIVE\\s+)?VIEW\\s+"ID"\\s+AS\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_MATERIALIZED,
+	 PM"CREATE\\s+MATERIALIZED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_MATVIEW_id,
+	 PM"CREATE\\s+MATERIALIZED\\s+VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_MATVIEW_id_any_AS,
+	 PM"CREATE\\s+MATERIALIZED\\s+VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?"ID"\\s+(?:.*\\s+)*AS\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_EVENT,
+	 PM"CREATE\\s+EVENT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_EVENT_TRIGGER_id,
+	 PM"CREATE\\s+EVENT\\s+TRIGGER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_EVENT_TRIGGER_id_ON,
+	 PM"CREATE\\s+EVENT\\s+TRIGGER\\s+"ID"\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DECLARE_id,
+	 PM"DECLARE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DECLARE_id_oBIN_oINSEN_oNOSCR_CURSOR,
+	 PM"DECLARE\\s+"ID"\\s+(?:BINARY\\s+)?(?:INSENSITIVE\\s+)?(?:(?:NO\\s+)?SCROLL\\s+)?CURSOR\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DELETE,
+	 PM"DELETE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DELETE_FROM,
+	 PM"DELETE\\s+FROM\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DELETE_FROM_id,
+	 PM"DELETE\\s+FROM\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DISCARD,
+	 PM"DISCARD\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DO,
+	 PM"DO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_AGGREGATE_id,
+	 PB"DROP\\s+AGGREGATE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_obj_1,
+	 PB"DROP\\s+(?:COLLATION|CONVERSION|DOMAIN|EXTENSION|FUNCTION|INDEX|LANGUAGE|SCHEMA|SEQUENCE|SERVER|TABLE|TYPE|VIEW)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_obj_2,
+	 PB"DROP\\s+AGGREGATE\\s*\\([^\\)]*\\)\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_obj_3,
+	 PB"DROP\\s+(?:(?:EVENT\\s+TRIGGER)|(?:FOREIGN\\s+DATA\\s+WRAPPER)|(?:TEXT\\s+SEARCH\\s+(?:COFIGURATION|PARSER|TEMPLATE)))\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_FUNCTION_id,
+	 PB"DROP\\s+FUNCTION\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+
+	{RE_DROP_FOREIGN,
+	 PM"DROP\\s+FOREIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_MATERIALIZED,
+	 PM"DROP\\s+MATERIALIZED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_MATERIALIZED_VIEW,
+	 PM"DROP\\s+MATERIALIZED\\s+VIEW\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_AGGoFUNC_id_,
+	 PM"DROP\\s+(?:AGGREATE|FUNCTION)\\s+(?:IF\\s+EXISTS\\s+)?("ID")\\s*\\(\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_OWNED,
+	 PM"DROP\\s+OWNED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_OWNED_BY,
+	 PM"DROP\\s+OWNED\\s+BY\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_TEXT_SEARARCH,
+	 PM"DROP\\s+TEXT\\s+SEARCH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_TRIGGER_id,
+	 PM"DROP\\s+TRIGGER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_TRIGGER_id_ON,
+	 PM"DROP\\s+TRIGGER\\s+("ID")\\s+ON\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_TRIGGER_id_ON_id,
+	 PM"DROP\\s+TRIGGER\\s+"ID"\\s+ON\\s+"ID"\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_EVENT,
+	 PM"DROP\\s+EVENT\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_EVENT_TRIGGER,
+	 PM"DROP\\s+EVENT\\s+TRIGGER\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_POLICY,
+	 PM"DROP\\s+POLICY\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_POLICY_id,
+	 PM"DROP\\s+POLICY\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_POLICY_id_ON,
+	 PM"DROP\\s+POLICY\\s+("ID")\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_RULE_id,
+	 PM"DROP\\s+RULE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_RULE_id_ON,
+	 PM"DROP\\s+RULE\\s+("ID")\\s+ON\\s+[\\w\"]*$", REG_ADVANCED|REG_ICASE},
+	{RE_DROP_RULE_id_ON_id,
+	 PM"DROP\\s+RULE\\s+"ID"\\s+ON\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_EXECUTE,
+	 PB"EXECUTE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_EXPLAIN,
+	 PM"EXPLAIN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_EXPLAIN_ANALYZE,
+	 PM"EXPLAIN\\s+ANALYZE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_EXPLAIN_oANALYZE_VERBOSE,
+	 PM"EXPLAIN\\s+(?:ANALYZE\\s+)?VERBOSE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FETCHoMOVE,
+	 PM"(?:FETCH|MOVE)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FETCHoMOVE_id,
+	 PM"(?:FETCH|MOVE)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FETCHoMOVE_any_any,
+	 PM"(?:FETCH|MOVE)\\s+\\w+\\s+\\w+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_negCREATE_FOREIGN_DATA_WRAPPER,
+	 PM"(?!CREATE)\\w+\\s+FOREIGN\\s+DATA\\s+WRAPPER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_negCREATE_FOREIGN_TABLE,
+	 PM"(?!CREATE)\\w+\\s+FOREIGN\\s+TABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FOREIGN_SERVER,
+	 "\\s+FOREIGN\\s+SERVER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE,
+	 PM"(?:GRANT|REVOKE)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd,
+	 PM"(?:GRANT|REVOKE)\\s+(?:SELECT|INSERT|UPDATE|DELETE|TRUNCATE|REFERENCES|TRIGGER|CREATE|CONNECT|(?:TEMP(?:ORARY)?)|EXECUTE|USAGE|ALL)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_id,
+	 PM"(GRANT|REVOKE)\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON,
+	 PM"(?:GRANT|REVOKE)\\s+\\w+\\s+ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_ALL,
+	 PM"(?:GRANT|REVOKE)\\s+\\w+\\s+ON\\s+ALL\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_FOREIGN,
+	 PM"(?:GRANT|REVOKE)\\s+\\w+\\s+ON\\s+FOREIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_any,
+	 PM"(GRANT|REVOKE)\\s+\\w+\\s+ON\\s+(\\w+)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_ALL_any_IN_SCHEMA_id,
+	 PM"(GRANT|REVOKE)\\s+\\w+\\s+ON\\s+ALL\\w+\\s+\\w+\\s+IN\\s+SCHEMA\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_FDW_id,
+	 PM"(GRANT|REVOKE)\\s+\\w+\\s+ON\\s+FOREIGN\\s+DATA\\s+WRAPPER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_FOREIGN_SERVER_id,
+	 PM"(GRANT|REVOKE)\\s+\\w+\\s+ON\\s+FOREIGN\\s+SERVER\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_any_TO,
+	 PM"(GRANT|REVOKE)\\s+.*\\s+(?:TO|FROM)+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_ON_kwd_id,
+	 PM"(GRANT|REVOKE)\\s+\\w+\\s+ON\\s+\\w+\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_GRANToREVOKE_kwd_TO,
+	 PM"(GRANT|REVOKE)\\s+\\w+\\s+(?:TO|FROM)+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FROM_any_GROUP,
+	 "\\s+FROM\\s+"ID"\\s+GROUP\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_IMPORT,
+	 PM"IMPORT+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_IMPORT_FOREIGN,
+	 PM"IMPORT+\\s+FOREIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_INSERT,
+	 PM"INSERT+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_INSERT_INTO,
+	 PM"INSERT+\\s+INTO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_INSERT_INTO_id_,
+	 PM"INSERT+\\s+INTO\\s+("ID")\\s*\\(\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_INSERT_INTO_id,
+	 PM"INSERT+\\s+INTO\\s+("ID")\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_INSERT_INTO_id__,
+	 PM"INSERT+\\s+INTO\\s+("ID")\\s*\\([^\\)]*\\)\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_negDEFAULT_VALUES,
+	 "(?!\\s+DEFAULT\\s+)VALUES\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_LOCK,
+	 PM"LOCK+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_LOCK_TABLE,
+	 PM"LOCK+\\s+TABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_LOCK_oTABLE_id,
+	 PM"LOCK+\\s+(?:TABLE\\s+)?\\w+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_LOCK_oTABLE_id_IN,
+	 PM"LOCK+\\s+(?:TABLE\\s+)?\\w+\\s+IN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_NOTIFY,
+	 PM"NOTIFY+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_OPTIONS,
+	 "\\s+OPTIONS\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_OWNER_TO,
+	 "\\s+OWNER\\s+TO\\s*\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FROM_any_ORDER,
+	 "\\s+FROM\\s+"ID"\\s+ORDER\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_FROM_any_ORDER_BY,
+	 "\\s+FROM\\s+("ID")\\s+ORDER\\s+BY\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_PREPARE_any_AS,
+	 PM"PREPARE\\s+"ID"\\s+AS\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REASSIGN,
+	 PM"REASSIGN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REASSIGN_OWNED,
+	 PM"REASSIGN\\s+OWNED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REASSIGN_OWNED_BY,
+	 PM"REASSIGN\\s+OWNED\\s+BY\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REASSIGN_OWNED_BY_id,
+	 PM"REASSIGN\\s+OWNED\\s+BY\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REASSIGN_OWNED_BY_id_TO,
+	 PM"REASSIGN\\s+OWNED\\s+BY\\s+"ID"\\s+TO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH,
+	 PM"REFRESH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED,
+	 PM"REFRESH\\s+MATERIALIZED\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW_CONC,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+CONCURRENTLY\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW_id,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW_CONC_id,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+CONCURRENTLY\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW_id_WITH,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+"ID"\\s+WITH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW_CONC_id_WITH,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+CONCURRENTLY\\s+"ID"\\s+WITH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REFRESH_MATERIALIZED_VIEW_id_WITH_NO,
+	 PM"REFRESH\\s+MATERIALIZED\\s+VIEW\\s+"ID"\\s+WITH\\s+NO\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REINDEX,
+	 PM"REINDEX\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_REINDEX_kwd,
+	 PM"REINDEX\\s+(\\w+)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SECURITY,
+	 PM"SECURITY\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SECURITY_LABEL,
+	 PM"SECURITY\\s+LABEL\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SECURITY_LABEL_FOR_id,
+	 PM"SECURITY\\s+LABEL\\s+FOR\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SECURITY_LABEL_oFORname_ON,
+	 PM"SECURITY\\s+LABEL\\s+(?:FOR\\s+"ID"\\s)?ON\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SECURITY_LABEL_ON_kwd_id,
+	 PM"SECURITY\\s+LABEL\\s+ON\\s+\\w+\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SEToRESET,
+	 PM"(?:RE)?SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SHOW,
+	 PM"SHOW\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_TRANSACTIONs,
+	 PM"(?:(?:(?:SET|START|BEGIN)\\s+TRANSACTION)|(?:BEGIN\\s+WORK)|(?:SET\\s+SESSION\\s+CHARACTERISTICS\\s+AS\\s+TRANSACTION))\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_TRANSACTIONs_ISOLATION,
+	 PM"(?:(?:(?:SET|START|BEGIN)\\s+TRANSACTION)|(?:BEGIN\\s+WORK)|(?:SET\\s+SESSION\\s+CHARACTERISTICS\\s+AS\\s+TRANSACTION))\\s+ISOLATION\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_TRANSACTIONs_ISOLATION_LEVEL,
+	 PM"(?:(?:(?:SET|START|BEGIN)\\s+TRANSACTION)|(?:BEGIN\\s+WORK)|(?:SET\\s+SESSION\\s+CHARACTERISTICS\\s+AS\\s+TRANSACTION))\\s+ISOLATION\\s+LEVEL\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_TRANSACTIONs_ISOLATION_LEVEL_READ,
+	 PM"(?:(?:(?:SET|START|BEGIN)\\s+TRANSACTION)|(?:BEGIN\\s+WORK)|(?:SET\\s+SESSION\\s+CHARACTERISTICS\\s+AS\\s+TRANSACTION))\\s+ISOLATION\\s+LEVEL\\s+READ\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_TRANSACTIONs_ISOLATION_LEVEL_REPEATABLE,
+	 PM"(?:(?:(?:SET|START|BEGIN)\\s+TRANSACTION)|(?:BEGIN\\s+WORK)|(?:SET\\s+SESSION\\s+CHARACTERISTICS\\s+AS\\s+TRANSACTION))\\s+ISOLATION\\s+LEVEL\\s+REPEATABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_TRANSACTIONs_READ,
+	 PM"(?:(?:(?:SET|START|BEGIN)\\s+TRANSACTION)|(?:BEGIN\\s+WORK)|(?:SET\\s+SESSION\\s+CHARACTERISTICS\\s+AS\\s+TRANSACTION))\\s+READ\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_CONSTRAINTS,
+	 PM"SET\\s+CONSTRAINTS\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_CONSTRAINTS_id,
+	 PM"SET\\s+CONSTRAINTS\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_ROLE,
+	 PM"SET\\s+ROLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_SESSION,
+	 PM"SET\\s+SESSION\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_SESSION_AUTH,
+	 PM"SET\\s+SESSION\\s+AUTHORIZATION\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_RESET_SESSION,
+	 PM"RESET\\s+SESSION\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_var,
+	 PM"SET\\s+(?!TABLESPACE|SCHEMA|(?:.*\\)[)=]))\\w+\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_SET_var_TOoEQ,
+	 PM"SET\\s+(?!TABLESPACE|SCHEMA|(?:.*\\)[)=]))(\\w+)(?:(?:\\s+TO\\s+)|(?:\\s*=\\s*))\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_START,
+	 PM"START\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_TABLE,
+	 PB"TABLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_TABLESAMPLE,
+	 "\\s+TABLESAMPLE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_TABLESAMPLE_id,
+	 "\\s+TABLESAMPLE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_TRUNCATE,
+	 PM"TRUNCATE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_UNLISTEN,
+	 PM"UNLISTEN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_UPDATE,
+	 "\\s+UPDATE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_UPDATE_id,
+	 "\\s+UPDATE\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_id_SET,
+	 "\\s+([\\w\"])+\\s+SET\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_UPDATE_id_SET_id,
+	 "\\s+UPDATE\\s+"ID"\\s+SET\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CRToALToDRP_USER_MAPPING,
+	 PM"(?:CREATE|ALTER|DROP)\\s+USER\\s+MAPPING\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CREATE_USER_MAPPING_FOR,
+	 PM"CREATE\\s+USER\\s+MAPPING\\s+FOR\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_ALToDRP_USER_MAPPING_FOR,
+	 PM"(?:ALTER|DROP)\\s+USER\\s+MAPPING\\s+FOR\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_CRToALToDRP_USER_MAPPING_FOR_id,
+	 PM"(?:CREATE|ALTER|DROP)\\s+USER\\s+MAPPING\\s+FOR\\s+"ID"\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_VACUUM,
+	 PM"VACUUM\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_VACUUM_FULLoFREEZE,
+	 PM"VACUUM\\s+(?:FULL|FREEZE)\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_VACUUM_FULLoFREEZE_ANALYZE,
+	 PM"VACUUM\\s+(?:FULL|FREEZE)\\s+ANALYZE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_VACUUM_FULLoFREEZE_VERBOSE,
+	 PM"VACUUM\\s+(?:FULL|FREEZE)\\s+VERBOSE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_VACUUM_VERBOSE,
+	 PM"VACUUM\\s+VERBOSE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_VACUUM_ANALYZE,
+	 PM"VACUUM\\s+ANALYZE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_ANLVRBoVRBANL,
+	 "\\s+(?:(?:ANALYZE\\s+VERBOSE)|(?:VERBOSE\\s+ANALYZE))\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_WITH,
+	 PB"WITH\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_ANALYZE,
+	 PM"ANALYZE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_id_WHERE,
+	 PM"("ID")\\s+WHERE\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_COPY_id_FROM,
+	 PM"\\\\?COPY\\s+"ID"\\s+FROM\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+	{RE_any_JOIN,
+	 PM"JOIN\\s+\\w*$", REG_ADVANCED|REG_ICASE},
+
+	{RE_meta_question,
+	 PM"\\\\\\?\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_CONNECT,
+	 PM"\\\\c(?:onnect)?\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_CONNECT_word,
+	 PM"\\\\c(?:onnect)?\\s+((?:\"[^\"]+\")|\\w+)\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_da,
+	 PM"\\\\da\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_db,
+	 PM"\\\\db\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dD,
+	 PM"\\\\dD\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_des,
+	 PM"\\\\des\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_deu,
+	 PM"\\\\deu\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dew,
+	 PM"\\\\dew\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_df,
+	 PM"\\\\df\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dFd,
+	 PM"\\\\dFd\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dFp,
+	 PM"\\\\dFp\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dFt,
+	 PM"\\\\dFt\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dF,
+	 PM"\\\\dF\\w*\\s+\\w*$", REG_ADVANCED},
+
+	{RE_meta_di,
+	 PM"\\\\di\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dL,
+	 PM"\\\\dL\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dn,
+	 PM"\\\\dn\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dpOz,
+	 PM"\\\\(?:dp|z)\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_ds,
+	 PM"\\\\ds\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dt,
+	 PM"\\\\dt\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dT,
+	 PM"\\\\dT\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_duOdg,
+	 PM"\\\\(?:du|dg)\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dv,
+	 PM"\\\\dv\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dx,
+	 PM"\\\\dx\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dm,
+	 PM"\\\\dm\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dE,
+	 PM"\\\\dE\\w*\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_dy,
+	 PM"\\\\dy\\w*\\s+\\w*$", REG_ADVANCED},
+
+	{RE_meta_d,
+	 PM"\\\\d\\w*\\s+\\w*$", REG_ADVANCED},
+
+	{RE_meta_ef,
+	 PM"\\\\ef\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_ev,
+	 PM"\\\\ev\\s+\\w*$", REG_ADVANCED},
+
+	{RE_meta_encoding,
+	 PM"\\\\encoding\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_h,
+	 PM"\\\\h(?:elp)?\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_password,
+	 PM"\\\\password\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_pset,
+	 PM"\\\\pset\\s+\\w*$", REG_ADVANCED},
+
+	{RE_meta_pset_id,
+	 PM"\\\\pset\\s+(\\w+)\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_unset,
+	 PM"\\\\unset\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_set,
+	 PM"\\\\set\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_set_id,
+	 PM"\\\\set\\s+(\\w+)\\s+\\w*$", REG_ADVANCED},
+
+	{RE_meta_sf,
+	 PM"\\\\sf\\+?\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_sv,
+	 PM"\\\\sv\\+?\\s+\\w*$", REG_ADVANCED},
+	{RE_meta_FILECMDS,
+	 PM"\\\\(?:cd|e|edit|g|i|include|ir|include_relative|o|out|s|w|write|lo_import)\\s+\\w*$", REG_ADVANCED},
+
+	{RE_AnySingleWord,
+	 "(?:[^\\s]\\s+)?\\s*(\\w+)\\s+"NWB"*$", REG_ADVANCED},
+	
+};
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index b58ec14..1eea2dd 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -54,6 +54,8 @@
 #include "common.h"
 #include "settings.h"
 #include "stringutils.h"
+#include "regex/regex.h"
+#include "catalog/pg_collation.h"
 
 #ifdef HAVE_RL_FILENAME_COMPLETION_FUNCTION
 #define filename_completion_function rl_filename_completion_function
@@ -792,6 +794,18 @@ typedef struct
 #define THING_NO_DROP		(1 << 1)	/* should not show up after DROP */
 #define THING_NO_SHOW		(THING_NO_CREATE | THING_NO_DROP)
 
+#define CAPBUFLEN 128
+#define MATCHNUM 5
+
+#define REGMATCH(patid) (regmatchret=pg_regexec(&re[patid], linebufw, wstrlen, 0, NULL, MATCHNUM, rmatches, 0), regmatchret == 0)
+#define MATCHBEG(n) (rmatches[n].rm_so)
+#define MATCHEND(n) (rmatches[n].rm_eo)
+#define MATCHLEN(n) (MATCHEND(n) - MATCHBEG(n))
+#define CAPCPYLEN(n)(MATCHLEN(n)<CAPBUFLEN ? MATCHLEN(n):CAPBUFLEN - 1)
+#define CAPTURE0(n) (strncpy(capbuf[n], linebuf + MATCHBEG(n), CAPCPYLEN(n)),capbuf[n][CAPCPYLEN(n)] = 0)
+#define CAPTURE(n)  (CAPTURE0(n), capbuf[n])
+#define CAPBUF(n)   (capbuf[n])
+
 static const pgsql_thing_t words_after_create[] = {
 	{"AGGREGATE", NULL, &Query_for_list_of_aggregates},
 	{"CAST", NULL, NULL},		/* Casts have complex structures for names, so
@@ -842,6 +856,9 @@ static const pgsql_thing_t words_after_create[] = {
 	{NULL}						/* end of list */
 };
 
+#include "tab-complete-re.h"
+
+static regex_t re[RE_NUM];
 
 /* Forward declaration of functions */
 static char **psql_completion(const char *text, int start, int end);
@@ -864,15 +881,68 @@ static char *pg_strdup_keyword_case(const char *s, const char *ref);
 static char *escape_string(const char *text);
 static PGresult *exec_query(const char *query);
 
-static void get_previous_words(int point, char **previous_words, int nwords);
-
 static char *get_guctype(const char *varname);
 
+static void regcomp_e(comp_def *redef, regex_t *re);
+static void tab_complete_init(void);
+
 #ifdef NOT_USED
 static char *quote_file_name(char *text, int match_type, char *quote_pointer);
 static char *dequote_file_name(char *text, char quote_char);
 #endif
 
+static int
+pg_ascii2wchar_with_len(const char *from, pg_wchar *to, int len)
+{
+	int			cnt = 0;
+
+	while (len > 0 && *from)
+	{
+		*to++ = *from++;
+		len--;
+		cnt++;
+	}
+	*to = 0;
+	return cnt;
+}
+
+static void
+regcomp_e(comp_def *redef, regex_t *re)
+{
+	pg_wchar	*pattern;
+	int patlen;
+	int ret;
+
+	pattern = pg_malloc(sizeof(pg_wchar) * (strlen(redef->pat) + 1));
+	patlen = pg_ascii2wchar_with_len(redef->pat, pattern, strlen(redef->pat));
+	
+	if ((ret = pg_regcomp(re, pattern, patlen,
+						  redef->cflags, C_COLLATION_OID)) != 0)
+	{
+		fprintf(stderr, "failed to compile regexp (%d):\"%s\"\n",
+				ret, redef->pat);
+		exit(1);
+	}
+	pg_free(pattern);
+}
+
+void
+tab_complete_init(void)
+{
+	static int initialized = 0;
+	int i;
+
+	if (initialized)
+		return;
+	initialized = 1;
+
+	for (i = 0 ; i < RE_NUM ; i++)
+	{
+		Assert(redef[i].pat_id == i);
+		regcomp_e(&redef[i], &re[i]);
+	}
+}
+
 
 /*
  * Initialize the readline library for our purposes.
@@ -887,12 +957,39 @@ initialize_readline(void)
 
 	completion_max_records = 1000;
 
+	tab_complete_init();
+
 	/*
 	 * There is a variable rl_completion_query_items for this but apparently
 	 * it's not defined everywhere.
 	 */
 }
 
+static pg_wchar *
+expand_wchar_buffer(pg_wchar *p, int *buflen, int newlen, int limit)
+{
+	pg_wchar *ret = p;
+	int       len1 = newlen - 1;
+
+	Assert(newlen > 0);
+	if (newlen >= *buflen)
+	{
+		int mask;
+
+		/* Allocate in size of 2^n. Minimum 256 wchars */
+		for (mask = 255 ; mask < limit && (len1 & mask) != len1 ;
+			 mask = (mask << 1) | 1);
+		
+		/* mask is (<new buffer length> - 1) here */
+		if (mask >= limit) return NULL; /* Exceeds limit */
+		
+		*buflen = mask + 1;
+		
+		ret = pg_realloc(p, (*buflen) * sizeof(pg_wchar));
+	}		
+
+	return ret;
+}
 
 /*
  * The completion function.
@@ -905,23 +1002,17 @@ initialize_readline(void)
 static char **
 psql_completion(const char *text, int start, int end)
 {
+	const char *linebuf = rl_line_buffer;
+	static pg_wchar	 *linebufw = NULL;
+	static int	     linebufwlen = 0;
+	int len, wstrlen;
+	regmatch_t rmatches[MATCHNUM];
+	char capbuf[MATCHNUM][CAPBUFLEN];
+	int regmatchret = 0;
+
 	/* This is the variable we'll return. */
 	char	  **matches = NULL;
 
-	/* This array will contain some scannage of the input line. */
-	char	   *previous_words[9];
-
-	/* For compactness, we use these macros to reference previous_words[]. */
-#define prev_wd   (previous_words[0])
-#define prev2_wd  (previous_words[1])
-#define prev3_wd  (previous_words[2])
-#define prev4_wd  (previous_words[3])
-#define prev5_wd  (previous_words[4])
-#define prev6_wd  (previous_words[5])
-#define prev7_wd  (previous_words[6])
-#define prev8_wd  (previous_words[7])
-#define prev9_wd  (previous_words[8])
-
 	static const char *const sql_commands[] = {
 		"ABORT", "ALTER", "ANALYZE", "BEGIN", "CHECKPOINT", "CLOSE", "CLUSTER",
 		"COMMENT", "COMMIT", "COPY", "CREATE", "DEALLOCATE", "DECLARE",
@@ -961,12 +1052,10 @@ psql_completion(const char *text, int start, int end)
 	completion_info_charp = NULL;
 	completion_info_charp2 = NULL;
 
-	/*
-	 * Scan the input line before our current position for the last few words.
-	 * According to those we'll make some smart decisions on what the user is
-	 * probably intending to type.
-	 */
-	get_previous_words(start, previous_words, lengthof(previous_words));
+	len = strlen(linebuf);
+	/* Expand string buffer if needed */
+	linebufw = expand_wchar_buffer(linebufw, &linebufwlen, len + 1, 2048); 
+	wstrlen = pg_ascii2wchar_with_len(linebuf, linebufw, strlen(linebuf));
 
 	/* If a backslash command was started, continue */
 	if (text[0] == '\\')
@@ -984,36 +1073,31 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* If no previous word, suggest one of the basic sql commands */
-	else if (prev_wd[0] == '\0')
+	else if (REGMATCH(RE_none))
 		COMPLETE_WITH_LIST(sql_commands);
 
 /* CREATE */
 	/* complete with something you can create */
-	else if (pg_strcasecmp(prev_wd, "CREATE") == 0)
+	else if (REGMATCH(RE_CREATE))
 		matches = completion_matches(text, create_command_generator);
 
 /* DROP, but not DROP embedded in other commands */
 	/* complete with something you can drop */
-	else if (pg_strcasecmp(prev_wd, "DROP") == 0 &&
-			 prev2_wd[0] == '\0')
+	else if (REGMATCH(RE_DROP))
 		matches = completion_matches(text, drop_command_generator);
 
 /* ALTER */
 
 	/* ALTER TABLE */
-	else if (pg_strcasecmp(prev2_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "TABLE") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_TABLE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables,
 								   "UNION SELECT 'ALL IN TABLESPACE'");
-	}
 
 	/*
 	 * complete with what you can alter (TABLE, GROUP, USER, ...) unless we're
 	 * in ALTER TABLE sth ALTER
 	 */
-	else if (pg_strcasecmp(prev_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLE") != 0)
+	else if (REGMATCH(RE_ALTER))
 	{
 		static const char *const list_ALTER[] =
 		{"AGGREGATE", "COLLATION", "CONVERSION", "DATABASE", "DEFAULT PRIVILEGES", "DOMAIN",
@@ -1026,9 +1110,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTER);
 	}
 	/* ALTER TABLE,INDEX,MATERIALIZED VIEW xxx ALL IN TABLESPACE xxx */
-	else if (pg_strcasecmp(prev4_wd, "ALL") == 0 &&
-			 pg_strcasecmp(prev3_wd, "IN") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TABLESPACE") == 0)
+	else if (REGMATCH(RE_ALL_IN_TABLESPACE_id))
 	{
 		static const char *const list_ALTERALLINTSPC[] =
 		{"SET TABLESPACE", "OWNED BY", NULL};
@@ -1036,38 +1118,24 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERALLINTSPC);
 	}
 	/* ALTER TABLE,INDEX,MATERIALIZED VIEW xxx ALL IN TABLESPACE xxx OWNED BY */
-	else if (pg_strcasecmp(prev6_wd, "ALL") == 0 &&
-			 pg_strcasecmp(prev5_wd, "IN") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLESPACE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "OWNED") == 0 &&
-			 pg_strcasecmp(prev4_wd, "BY") == 0)
-	{
+	else if (REGMATCH(RE_ALL_IN_TABLESPACE_id_OWNED_BY))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
-	}
 	/* ALTER AGGREGATE,FUNCTION <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "AGGREGATE") == 0 ||
-			  pg_strcasecmp(prev2_wd, "FUNCTION") == 0))
+	else if (REGMATCH(RE_ALTER_AGGREGATEoFUNCTION))
 		COMPLETE_WITH_CONST("(");
 	/* ALTER AGGREGATE,FUNCTION <name> (...) */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "AGGREGATE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "FUNCTION") == 0))
+	else if (REGMATCH(RE_ALTER_AGGREGATEoFUNCTION_))
+		COMPLETE_WITH_FUNCTION_ARG(CAPTURE(1));
+	else if (REGMATCH(RE_ALTER_AGGREGATEoFUNCTION__))
 	{
-		if (prev_wd[strlen(prev_wd) - 1] == ')')
-		{
-			static const char *const list_ALTERAGG[] =
+		static const char *const list_ALTERAGG[] =
 			{"OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
 
-			COMPLETE_WITH_LIST(list_ALTERAGG);
-		}
-		else
-			COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
+		COMPLETE_WITH_LIST(list_ALTERAGG);
 	}
 
 	/* ALTER SCHEMA <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SCHEMA") == 0)
+	else if (REGMATCH(RE_ALTER_SCHEMA_id))
 	{
 		static const char *const list_ALTERGEN[] =
 		{"OWNER TO", "RENAME TO", NULL};
@@ -1076,18 +1144,15 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER COLLATION <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "COLLATION") == 0)
+	else if (REGMATCH(RE_ALTER_COLLATION_id))
 	{
 		static const char *const list_ALTERGEN[] =
 		{"OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERGEN);
 	}
-
-	/* ALTER CONVERSION <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONVERSION") == 0)
+	/* ALTER COLLATION/CONVERSION <name> */
+	else if (REGMATCH(RE_ALTER_CONVERSION_id))
 	{
 		static const char *const list_ALTERGEN[] =
 		{"OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
@@ -1096,8 +1161,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER DATABASE <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DATABASE") == 0)
+	else if (REGMATCH(RE_ALTER_DATABASE_id))
 	{
 		static const char *const list_ALTERDATABASE[] =
 		{"RESET", "SET", "OWNER TO", "RENAME TO", "IS_TEMPLATE",
@@ -1107,17 +1171,11 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER EVENT TRIGGER */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev_wd, "TRIGGER") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_EVENT_TRIGGER))
 		COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
-	}
 
 	/* ALTER EVENT TRIGGER <name> */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_ALTER_EVENT_TRIGGER_id))
 	{
 		static const char *const list_ALTER_EVENT_TRIGGER[] =
 		{"DISABLE", "ENABLE", "OWNER TO", "RENAME TO", NULL};
@@ -1126,10 +1184,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER EVENT TRIGGER <name> ENABLE */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev_wd, "ENABLE") == 0)
+	else if (REGMATCH(RE_ALTER_EVENT_TRIGGER_id_ENABLE))
 	{
 		static const char *const list_ALTER_EVENT_TRIGGER_ENABLE[] =
 		{"REPLICA", "ALWAYS", NULL};
@@ -1138,8 +1193,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER EXTENSION <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "EXTENSION") == 0)
+	else if (REGMATCH(RE_ALTER_EXTENSION_id))
 	{
 		static const char *const list_ALTEREXTENSION[] =
 		{"ADD", "DROP", "UPDATE", "SET SCHEMA", NULL};
@@ -1148,8 +1202,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER FOREIGN */
-	else if (pg_strcasecmp(prev2_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOREIGN") == 0)
+	else if (REGMATCH(RE_ALTER_FOREIGN))
 	{
 		static const char *const list_ALTER_FOREIGN[] =
 		{"DATA WRAPPER", "TABLE", NULL};
@@ -1158,10 +1211,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER FOREIGN DATA WRAPPER <name> */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DATA") == 0 &&
-			 pg_strcasecmp(prev2_wd, "WRAPPER") == 0)
+	else if (REGMATCH(RE_ALTER_FOREIGN_DATA_WRAPPER_id))
 	{
 		static const char *const list_ALTER_FDW[] =
 		{"HANDLER", "VALIDATOR", "OPTIONS", "OWNER TO", NULL};
@@ -1170,9 +1220,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER FOREIGN TABLE <name> */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TABLE") == 0)
+	else if (REGMATCH(RE_ALTER_FOREIGN_TABLE_id))
 	{
 		static const char *const list_ALTER_FOREIGN_TABLE[] =
 		{"ADD", "ALTER", "DISABLE TRIGGER", "DROP", "ENABLE", "INHERIT",
@@ -1183,15 +1231,11 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER INDEX */
-	else if (pg_strcasecmp(prev2_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "INDEX") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_INDEX))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes,
 								   "UNION SELECT 'ALL IN TABLESPACE'");
-	}
 	/* ALTER INDEX <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "INDEX") == 0)
+	else if (REGMATCH(RE_ALTER_INDEX_id))
 	{
 		static const char *const list_ALTERINDEX[] =
 		{"OWNER TO", "RENAME TO", "SET", "RESET", NULL};
@@ -1199,9 +1243,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERINDEX);
 	}
 	/* ALTER INDEX <name> SET */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "INDEX") == 0 &&
-			 pg_strcasecmp(prev_wd, "SET") == 0)
+	else if (REGMATCH(RE_ALTER_INDEX_id_SET))
 	{
 		static const char *const list_ALTERINDEXSET[] =
 		{"(", "TABLESPACE", NULL};
@@ -1209,25 +1251,17 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERINDEXSET);
 	}
 	/* ALTER INDEX <name> RESET */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "INDEX") == 0 &&
-			 pg_strcasecmp(prev_wd, "RESET") == 0)
+	else if (REGMATCH(RE_ALTER_INDEX_id_RESET))
 		COMPLETE_WITH_CONST("(");
 	/* ALTER INDEX <foo> SET|RESET ( */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "INDEX") == 0 &&
-			 pg_strcasecmp(prev2_wd, "RESET") == 0 &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
+	else if (REGMATCH(RE_ALTER_INDEX_id_RESET_))
 	{
 		static const char *const list_INDEXOPTIONS[] =
 		{"fillfactor", "fastupdate", "gin_pending_list_limit", NULL};
 
 		COMPLETE_WITH_LIST(list_INDEXOPTIONS);
 	}
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "INDEX") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
+	else if (REGMATCH(RE_ALTER_INDEX_id_SET_))
 	{
 		static const char *const list_INDEXOPTIONS[] =
 		{"fillfactor =", "fastupdate =", "gin_pending_list_limit =", NULL};
@@ -1236,8 +1270,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER LANGUAGE <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "LANGUAGE") == 0)
+	else if (REGMATCH(RE_ALTER_LANGUAGE_id))
 	{
 		static const char *const list_ALTERLANGUAGE[] =
 		{"OWNER TO", "RENAME TO", NULL};
@@ -1246,9 +1279,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER LARGE OBJECT <oid> */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "LARGE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "OBJECT") == 0)
+	else if (REGMATCH(RE_ALTER_LARGE_OBJECT_oid))
 	{
 		static const char *const list_ALTERLARGEOBJECT[] =
 		{"OWNER TO", NULL};
@@ -1257,19 +1288,12 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER MATERIALIZED VIEW */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev_wd, "VIEW") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_MATERIALIZED_VIEW))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews,
 								   "UNION SELECT 'ALL IN TABLESPACE'");
-	}
 
 	/* ALTER USER,ROLE <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 !(pg_strcasecmp(prev2_wd, "USER") == 0 && pg_strcasecmp(prev_wd, "MAPPING") == 0) &&
-			 (pg_strcasecmp(prev2_wd, "USER") == 0 ||
-			  pg_strcasecmp(prev2_wd, "ROLE") == 0))
+	else if (REGMATCH(RE_ALTER_USERoROLE_id))
 	{
 		static const char *const list_ALTERUSER[] =
 		{"BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE",
@@ -1283,10 +1307,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER USER,ROLE <name> WITH */
-	else if ((pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			  (pg_strcasecmp(prev3_wd, "USER") == 0 ||
-			   pg_strcasecmp(prev3_wd, "ROLE") == 0) &&
-			  pg_strcasecmp(prev_wd, "WITH") == 0))
+	else if (REGMATCH(RE_ALTER_USERoROLE_id_WITH))
 	{
 		/* Similar to the above, but don't complete "WITH" again. */
 		static const char *const list_ALTERUSER_WITH[] =
@@ -1301,16 +1322,11 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* complete ALTER USER,ROLE <name> ENCRYPTED,UNENCRYPTED with PASSWORD */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "ROLE") == 0 || pg_strcasecmp(prev3_wd, "USER") == 0) &&
-			 (pg_strcasecmp(prev_wd, "ENCRYPTED") == 0 || pg_strcasecmp(prev_wd, "UNENCRYPTED") == 0))
-	{
+	else if (REGMATCH(RE_ALTER_USERoROLE_id_ENCoUNENC))
 		COMPLETE_WITH_CONST("PASSWORD");
-	}
+
 	/* ALTER DEFAULT PRIVILEGES */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DEFAULT") == 0 &&
-			 pg_strcasecmp(prev_wd, "PRIVILEGES") == 0)
+	else if (REGMATCH(RE_ALTER_DEFAULT_PRIVILEGES))
 	{
 		static const char *const list_ALTER_DEFAULT_PRIVILEGES[] =
 		{"FOR ROLE", "FOR USER", "IN SCHEMA", NULL};
@@ -1318,10 +1334,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTER_DEFAULT_PRIVILEGES);
 	}
 	/* ALTER DEFAULT PRIVILEGES FOR */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DEFAULT") == 0 &&
-			 pg_strcasecmp(prev2_wd, "PRIVILEGES") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOR") == 0)
+	else if (REGMATCH(RE_ALTER_DEFAULT_PRIVILEGES_FOR))
 	{
 		static const char *const list_ALTER_DEFAULT_PRIVILEGES_FOR[] =
 		{"ROLE", "USER", NULL};
@@ -1329,10 +1342,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTER_DEFAULT_PRIVILEGES_FOR);
 	}
 	/* ALTER DEFAULT PRIVILEGES { FOR ROLE ... | IN SCHEMA ... } */
-	else if (pg_strcasecmp(prev5_wd, "DEFAULT") == 0 &&
-			 pg_strcasecmp(prev4_wd, "PRIVILEGES") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "FOR") == 0 ||
-			  pg_strcasecmp(prev3_wd, "IN") == 0))
+	else if (REGMATCH(RE_ALTER_DEFAULT_PRIVILEGES_FORROLEoINSCHEMA_id))
 	{
 		static const char *const list_ALTER_DEFAULT_PRIVILEGES_REST[] =
 		{"GRANT", "REVOKE", NULL};
@@ -1340,8 +1350,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTER_DEFAULT_PRIVILEGES_REST);
 	}
 	/* ALTER DOMAIN <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DOMAIN") == 0)
+	else if (REGMATCH(RE_ALTER_DOMAIN_id))
 	{
 		static const char *const list_ALTERDOMAIN[] =
 		{"ADD", "DROP", "OWNER TO", "RENAME", "SET", "VALIDATE CONSTRAINT", NULL};
@@ -1349,9 +1358,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERDOMAIN);
 	}
 	/* ALTER DOMAIN <sth> DROP */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DOMAIN") == 0 &&
-			 pg_strcasecmp(prev_wd, "DROP") == 0)
+	else if (REGMATCH(RE_ALTER_DOMAIN_id_DROP))
 	{
 		static const char *const list_ALTERDOMAIN2[] =
 		{"CONSTRAINT", "DEFAULT", "NOT NULL", NULL};
@@ -1359,20 +1366,13 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERDOMAIN2);
 	}
 	/* ALTER DOMAIN <sth> DROP|RENAME|VALIDATE CONSTRAINT */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "DOMAIN") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "DROP") == 0 ||
-			  pg_strcasecmp(prev2_wd, "RENAME") == 0 ||
-			  pg_strcasecmp(prev2_wd, "VALIDATE") == 0) &&
-			 pg_strcasecmp(prev_wd, "CONSTRAINT") == 0)
-	{
-		completion_info_charp = prev3_wd;
+	else if (REGMATCH(RE_ALTER_DOMAIN_sth_DROPoRENAMEoVALIDATE_CONSTRAINT))
+	{
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_constraint_of_type);
 	}
 	/* ALTER DOMAIN <sth> RENAME */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DOMAIN") == 0 &&
-			 pg_strcasecmp(prev_wd, "RENAME") == 0)
+	else if (REGMATCH(RE_ALTER_DOMAIN_id_RENAME))
 	{
 		static const char *const list_ALTERDOMAIN[] =
 		{"CONSTRAINT", "TO", NULL};
@@ -1380,15 +1380,11 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERDOMAIN);
 	}
 	/* ALTER DOMAIN <sth> RENAME CONSTRAINT <sth> */
-	else if (pg_strcasecmp(prev5_wd, "DOMAIN") == 0 &&
-			 pg_strcasecmp(prev3_wd, "RENAME") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONSTRAINT") == 0)
+	else if (REGMATCH(RE_ALTER_DOMAIN_id_RENAME_CONSTRAINT))
 		COMPLETE_WITH_CONST("TO");
 
 	/* ALTER DOMAIN <sth> SET */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DOMAIN") == 0 &&
-			 pg_strcasecmp(prev_wd, "SET") == 0)
+	else if (REGMATCH(RE_ALTER_DOMAIN_id_SET))
 	{
 		static const char *const list_ALTERDOMAIN3[] =
 		{"DEFAULT", "NOT NULL", "SCHEMA", NULL};
@@ -1396,8 +1392,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERDOMAIN3);
 	}
 	/* ALTER SEQUENCE <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SEQUENCE") == 0)
+	else if (REGMATCH(RE_ALTER_SEQUENCE_id))
 	{
 		static const char *const list_ALTERSEQUENCE[] =
 		{"INCREMENT", "MINVALUE", "MAXVALUE", "RESTART", "NO", "CACHE", "CYCLE",
@@ -1406,9 +1401,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERSEQUENCE);
 	}
 	/* ALTER SEQUENCE <name> NO */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "SEQUENCE") == 0 &&
-			 pg_strcasecmp(prev_wd, "NO") == 0)
+	else if (REGMATCH(RE_ALTER_SEQUENCE_id_NO))
 	{
 		static const char *const list_ALTERSEQUENCE2[] =
 		{"MINVALUE", "MAXVALUE", "CYCLE", NULL};
@@ -1416,32 +1409,26 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERSEQUENCE2);
 	}
 	/* ALTER SERVER <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SERVER") == 0)
+	else if (REGMATCH(RE_ALTER_SERVER_id))
 	{
 		static const char *const list_ALTER_SERVER[] =
 		{"VERSION", "OPTIONS", "OWNER TO", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTER_SERVER);
 	}
-	/* ALTER SYSTEM SET, RESET, RESET ALL */
-	else if (pg_strcasecmp(prev2_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "SYSTEM") == 0)
+	/* ALTER SYSTEM  */
+	else if (REGMATCH(RE_ALTER_SYSTEM))
 	{
 		static const char *const list_ALTERSYSTEM[] =
 		{"SET", "RESET", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERSYSTEM);
 	}
-	/* ALTER SYSTEM SET|RESET <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SYSTEM") == 0 &&
-			 (pg_strcasecmp(prev_wd, "SET") == 0 ||
-			  pg_strcasecmp(prev_wd, "RESET") == 0))
+	/* ALTER SYSTEM SET|RESET */
+	else if (REGMATCH(RE_ALTER_SYSTEM_SEToRESET))
 		COMPLETE_WITH_QUERY(Query_for_list_of_alter_system_set_vars);
 	/* ALTER VIEW <name> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VIEW") == 0)
+	else if (REGMATCH(RE_ALTER_VIEW_id))
 	{
 		static const char *const list_ALTERVIEW[] =
 		{"ALTER COLUMN", "OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
@@ -1449,9 +1436,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERVIEW);
 	}
 	/* ALTER MATERIALIZED VIEW <name> */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VIEW") == 0)
+	else if (REGMATCH(RE_ALTER_MVIEW_id))
 	{
 		static const char *const list_ALTERMATVIEW[] =
 		{"ALTER COLUMN", "OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
@@ -1459,94 +1444,65 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERMATVIEW);
 	}
 
-	/* ALTER POLICY <name> ON */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "POLICY") == 0)
+	/* ALTER POLICY <name> */
+	else if (REGMATCH(RE_ALTER_POLICY_id))
 		COMPLETE_WITH_CONST("ON");
 	/* ALTER POLICY <name> ON <table> */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_ALTER_POLICY_id_ON))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
 	/* ALTER POLICY <name> ON <table> - show options */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_ALTER_POLICY_id_ON_table))
 	{
 		static const char *const list_ALTERPOLICY[] =
 		{"RENAME TO", "TO", "USING", "WITH CHECK", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERPOLICY);
 	}
-	/* ALTER POLICY <name> ON <table> TO <role> */
-	else if (pg_strcasecmp(prev6_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev5_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "TO") == 0)
+	/* ALTER POLICY <name> ON <table> TO */
+	else if (REGMATCH(RE_ALTER_POLICY_id_ON_table_TO))
 		COMPLETE_WITH_QUERY(Query_for_list_of_grant_roles);
-	/* ALTER POLICY <name> ON <table> USING ( */
-	else if (pg_strcasecmp(prev6_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev5_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "USING") == 0)
+	/* ALTER POLICY <name> ON <table> USING */
+	else if (REGMATCH(RE_ALTER_POLICY_id_ON_table_USING))
 		COMPLETE_WITH_CONST("(");
-	/* ALTER POLICY <name> ON <table> WITH CHECK ( */
-	else if (pg_strcasecmp(prev6_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "WITH") == 0 &&
-			 pg_strcasecmp(prev_wd, "CHECK") == 0)
+	/* ALTER POLICY <name> ON <table> WITH CHECK */
+	else if (REGMATCH(RE_ALTER_POLICY_id_ON_table_WITH_CHECK))
 		COMPLETE_WITH_CONST("(");
-
-	/* ALTER RULE <name>, add ON */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "RULE") == 0)
+	/* ALTER RULE <name> */
+	else if (REGMATCH(RE_ALTER_RULE_id))
 		COMPLETE_WITH_CONST("ON");
 
 	/* If we have ALTER RULE <name> ON, then add the correct tablename */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "RULE") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_ALTER_RULE_id_ON))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_rule);
 	}
 
 	/* ALTER RULE <name> ON <name> */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "RULE") == 0)
+	else if (REGMATCH(RE_ALTER_RULE_id_ON_id))
 		COMPLETE_WITH_CONST("RENAME TO");
 
 	/* ALTER TRIGGER <name>, add ON */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_ALTER_TRIGGER_id))
 		COMPLETE_WITH_CONST("ON");
 
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TRIGGER") == 0)
-	{
-		completion_info_charp = prev2_wd;
-		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_trigger);
-	}
-
 	/*
 	 * If we have ALTER TRIGGER <sth> ON, then add the correct tablename
 	 */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
-		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
+	else if (REGMATCH(RE_ALTER_TRIGGER_id_ON))
+	{
+		completion_info_charp = CAPTURE(1);
+		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_trigger);
+	}
 
 	/* ALTER TRIGGER <name> ON <name> */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_ALTER_TRIGGER_id_ON_id))
 		COMPLETE_WITH_CONST("RENAME TO");
 
 	/*
 	 * If we detect ALTER TABLE <name>, suggest sub commands
 	 */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TABLE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id))
 	{
 		static const char *const list_ALTER2[] =
 		{"ADD", "ALTER", "CLUSTER ON", "DISABLE", "DROP", "ENABLE", "INHERIT",
@@ -1556,102 +1512,66 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTER2);
 	}
 	/* ALTER TABLE xxx ENABLE */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "ENABLE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ENABLE))
 	{
 		static const char *const list_ALTERENABLE[] =
 		{"ALWAYS", "REPLICA", "ROW LEVEL SECURITY", "RULE", "TRIGGER", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERENABLE);
 	}
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ENABLE") == 0 &&
-			 (pg_strcasecmp(prev_wd, "REPLICA") == 0 ||
-			  pg_strcasecmp(prev_wd, "ALWAYS") == 0))
+	else if (REGMATCH(RE_ALTER_TABLE_id_ENABLE_REPLICAoALWAYS))
 	{
 		static const char *const list_ALTERENABLE2[] =
 		{"RULE", "TRIGGER", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERENABLE2);
 	}
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ENABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "RULE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ENABLE_RULE))
 	{
-		completion_info_charp = prev3_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_rule_of_table);
 	}
-	else if (pg_strcasecmp(prev6_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev5_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ENABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "RULE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ENABLE_kwd_RULE))
 	{
-		completion_info_charp = prev4_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_rule_of_table);
 	}
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ENABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ENABLE_TRIGGER))
 	{
-		completion_info_charp = prev3_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_trigger_of_table);
 	}
-	else if (pg_strcasecmp(prev6_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev5_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ENABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ENABLE_kwd_TRIGGER))
 	{
-		completion_info_charp = prev4_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_trigger_of_table);
 	}
 	/* ALTER TABLE xxx INHERIT */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "INHERIT") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_TABLE_id_INHERIT))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, "");
-	}
 	/* ALTER TABLE xxx NO INHERIT */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "NO") == 0 &&
-			 pg_strcasecmp(prev_wd, "INHERIT") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_TABLE_id_NOINHERIT))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, "");
-	}
 	/* ALTER TABLE xxx DISABLE */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "DISABLE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_DISABLE))
 	{
 		static const char *const list_ALTERDISABLE[] =
 		{"ROW LEVEL SECURITY", "RULE", "TRIGGER", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERDISABLE);
 	}
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DISABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "RULE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_DISABLE_RULE))
 	{
-		completion_info_charp = prev3_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_rule_of_table);
 	}
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DISABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_DISABLE_TRIGGER))
 	{
-		completion_info_charp = prev3_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_trigger_of_table);
 	}
-	else if (pg_strcasecmp(prev4_wd, "DISABLE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ROW") == 0 &&
-			 pg_strcasecmp(prev2_wd, "LEVEL") == 0 &&
-			 pg_strcasecmp(prev_wd, "SECURITY") == 0)
+
+	else if (REGMATCH(RE_ALTER_TABLE_id_DISABLE_ROW_LEVEL_SECURITY))
 	{
 		static const char *const list_DISABLERLS[] =
 		{"CASCADE", NULL};
@@ -1660,45 +1580,28 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER TABLE xxx ALTER */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "ALTER") == 0)
-		COMPLETE_WITH_ATTR(prev2_wd, " UNION SELECT 'COLUMN' UNION SELECT 'CONSTRAINT'");
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTER))
+		COMPLETE_WITH_ATTR(CAPTURE(1), " UNION SELECT 'COLUMN' UNION SELECT 'CONSTRAINT'");
 
 	/* ALTER TABLE xxx RENAME */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "RENAME") == 0)
-		COMPLETE_WITH_ATTR(prev2_wd, " UNION SELECT 'COLUMN' UNION SELECT 'CONSTRAINT' UNION SELECT 'TO'");
+	else if (REGMATCH(RE_ALTER_TABLE_id_RENAME))
+		COMPLETE_WITH_ATTR(CAPTURE(1), " UNION SELECT 'COLUMN' UNION SELECT 'CONSTRAINT' UNION SELECT 'TO'");
 
 	/*
 	 * If we have TABLE <sth> ALTER COLUMN|RENAME COLUMN, provide list of
 	 * columns
 	 */
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "ALTER") == 0 ||
-			  pg_strcasecmp(prev2_wd, "RENAME") == 0) &&
-			 pg_strcasecmp(prev_wd, "COLUMN") == 0)
-		COMPLETE_WITH_ATTR(prev3_wd, "");
-
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTERoRENAME_COLUMN))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 	/* ALTER TABLE xxx RENAME yyy */
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "RENAME") == 0 &&
-			 pg_strcasecmp(prev_wd, "CONSTRAINT") != 0 &&
-			 pg_strcasecmp(prev_wd, "TO") != 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_RENAME_negCONSTRAINToTO))
 		COMPLETE_WITH_CONST("TO");
-
 	/* ALTER TABLE xxx RENAME COLUMN/CONSTRAINT yyy */
-	else if (pg_strcasecmp(prev5_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "RENAME") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "COLUMN") == 0 ||
-			  pg_strcasecmp(prev2_wd, "CONSTRAINT") == 0) &&
-			 pg_strcasecmp(prev_wd, "TO") != 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_RENAME_COLUMNoCONSTRAINT_negTO))
 		COMPLETE_WITH_CONST("TO");
 
 	/* If we have TABLE <sth> DROP, provide COLUMN or CONSTRAINT */
-	else if (pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "DROP") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_DROP))
 	{
 		static const char *const list_TABLEDROP[] =
 		{"COLUMN", "CONSTRAINT", NULL};
@@ -1706,32 +1609,20 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_TABLEDROP);
 	}
 	/* If we have ALTER TABLE <sth> DROP COLUMN, provide list of columns */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev_wd, "COLUMN") == 0)
-		COMPLETE_WITH_ATTR(prev3_wd, "");
+	else if (REGMATCH(RE_ALTER_TABLE_id_DROP_COLUMN))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 
 	/*
 	 * If we have ALTER TABLE <sth> ALTER|DROP|RENAME|VALIDATE CONSTRAINT,
 	 * provide list of constraints
 	 */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "ALTER") == 0 ||
-			  pg_strcasecmp(prev2_wd, "DROP") == 0 ||
-			  pg_strcasecmp(prev2_wd, "RENAME") == 0 ||
-			  pg_strcasecmp(prev2_wd, "VALIDATE") == 0) &&
-			 pg_strcasecmp(prev_wd, "CONSTRAINT") == 0)
-	{
-		completion_info_charp = prev3_wd;
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALToDROPoRENoVALIDATE_CONSTR))
+	{
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_constraint_of_table);
 	}
 	/* ALTER TABLE ALTER [COLUMN] <foo> */
-	else if ((pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			  pg_strcasecmp(prev2_wd, "COLUMN") == 0) ||
-			 (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			  pg_strcasecmp(prev2_wd, "ALTER") == 0))
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTER_oCOLUMN_id))
 	{
 		static const char *const list_COLUMNALTER[] =
 		{"TYPE", "SET", "RESET", "DROP", NULL};
@@ -1739,11 +1630,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_COLUMNALTER);
 	}
 	/* ALTER TABLE ALTER [COLUMN] <foo> SET */
-	else if (((pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			   pg_strcasecmp(prev3_wd, "COLUMN") == 0) ||
-			  (pg_strcasecmp(prev5_wd, "TABLE") == 0 &&
-			   pg_strcasecmp(prev3_wd, "ALTER") == 0)) &&
-			 pg_strcasecmp(prev_wd, "SET") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET))
 	{
 		static const char *const list_COLUMNSET[] =
 		{"(", "DEFAULT", "NOT NULL", "STATISTICS", "STORAGE", NULL};
@@ -1751,11 +1638,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_COLUMNSET);
 	}
 	/* ALTER TABLE ALTER [COLUMN] <foo> SET ( */
-	else if (((pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			   pg_strcasecmp(prev4_wd, "COLUMN") == 0) ||
-			  pg_strcasecmp(prev4_wd, "ALTER") == 0) &&
-			 pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET_))
 	{
 		static const char *const list_COLUMNOPTIONS[] =
 		{"n_distinct", "n_distinct_inherited", NULL};
@@ -1763,11 +1646,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_COLUMNOPTIONS);
 	}
 	/* ALTER TABLE ALTER [COLUMN] <foo> SET STORAGE */
-	else if (((pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			   pg_strcasecmp(prev4_wd, "COLUMN") == 0) ||
-			  pg_strcasecmp(prev4_wd, "ALTER") == 0) &&
-			 pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "STORAGE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_SET_STORAGE))
 	{
 		static const char *const list_COLUMNSTORAGE[] =
 		{"PLAIN", "EXTERNAL", "EXTENDED", "MAIN", NULL};
@@ -1775,30 +1654,22 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_COLUMNSTORAGE);
 	}
 	/* ALTER TABLE ALTER [COLUMN] <foo> DROP */
-	else if (((pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			   pg_strcasecmp(prev3_wd, "COLUMN") == 0) ||
-			  (pg_strcasecmp(prev5_wd, "TABLE") == 0 &&
-			   pg_strcasecmp(prev3_wd, "ALTER") == 0)) &&
-			 pg_strcasecmp(prev_wd, "DROP") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_ALTER_oCOLUMN_id_DROP))
 	{
 		static const char *const list_COLUMNDROP[] =
 		{"DEFAULT", "NOT NULL", NULL};
 
 		COMPLETE_WITH_LIST(list_COLUMNDROP);
 	}
-	else if (pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "CLUSTER") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_CLUSTER))
 		COMPLETE_WITH_CONST("ON");
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CLUSTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_CLUSTER_ON))
 	{
-		completion_info_charp = prev3_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_index_of_table);
 	}
 	/* If we have TABLE <sth> SET, provide list of attributes and '(' */
-	else if (pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "SET") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_SET))
 	{
 		static const char *const list_TABLESET[] =
 		{"(", "LOGGED", "SCHEMA", "TABLESPACE", "UNLOGGED", "WITH", "WITHOUT", NULL};
@@ -1806,14 +1677,10 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_TABLESET);
 	}
 	/* If we have TABLE <sth> SET TABLESPACE provide a list of tablespaces */
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "TABLESPACE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_SET_TABLESPACE))
 		COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
 	/* If we have TABLE <sth> SET WITHOUT provide CLUSTER or OIDS */
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "WITHOUT") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_SET_WITHOUT))
 	{
 		static const char *const list_TABLESET2[] =
 		{"CLUSTER", "OIDS", NULL};
@@ -1821,14 +1688,10 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_TABLESET2);
 	}
 	/* ALTER TABLE <foo> RESET */
-	else if (pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "RESET") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_RESET))
 		COMPLETE_WITH_CONST("(");
 	/* ALTER TABLE <foo> SET|RESET ( */
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "SET") == 0 ||
-			  pg_strcasecmp(prev2_wd, "RESET") == 0) &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_RESET_))
 	{
 		static const char *const list_TABLEOPTIONS[] =
 		{
@@ -1865,39 +1728,25 @@ psql_completion(const char *text, int start, int end)
 
 		COMPLETE_WITH_LIST(list_TABLEOPTIONS);
 	}
-	else if (pg_strcasecmp(prev4_wd, "REPLICA") == 0 &&
-			 pg_strcasecmp(prev3_wd, "IDENTITY") == 0 &&
-			 pg_strcasecmp(prev2_wd, "USING") == 0 &&
-			 pg_strcasecmp(prev_wd, "INDEX") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_REPLICA_IDENTITY_USING_INDEX))
 	{
-		completion_info_charp = prev5_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_index_of_table);
 	}
-	else if (pg_strcasecmp(prev5_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "REPLICA") == 0 &&
-			 pg_strcasecmp(prev2_wd, "IDENTITY") == 0 &&
-			 pg_strcasecmp(prev_wd, "USING") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_TABLE_id_REPLICA_IDENTITY_USING))
 		COMPLETE_WITH_CONST("INDEX");
-	}
-	else if (pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "REPLICA") == 0 &&
-			 pg_strcasecmp(prev_wd, "IDENTITY") == 0)
+	else if (REGMATCH(RE_ALTER_TABLE_id_REPLICA_IDENTITY))
 	{
 		static const char *const list_REPLICAID[] =
 		{"FULL", "NOTHING", "DEFAULT", "USING", NULL};
 
 		COMPLETE_WITH_LIST(list_REPLICAID);
 	}
-	else if (pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev_wd, "REPLICA") == 0)
-	{
+	else if (REGMATCH(RE_ALTER_TABLE_id_REPLICA))
 		COMPLETE_WITH_CONST("IDENTITY");
-	}
 
 	/* ALTER TABLESPACE <foo> with RENAME TO, OWNER TO, SET, RESET */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TABLESPACE") == 0)
+	else if (REGMATCH(RE_ALTER_TABLESPACE_id))
 	{
 		static const char *const list_ALTERTSPC[] =
 		{"RENAME TO", "OWNER TO", "SET", "RESET", NULL};
@@ -1905,17 +1754,10 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERTSPC);
 	}
 	/* ALTER TABLESPACE <foo> SET|RESET */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TABLESPACE") == 0 &&
-			 (pg_strcasecmp(prev_wd, "SET") == 0 ||
-			  pg_strcasecmp(prev_wd, "RESET") == 0))
+	else if (REGMATCH(RE_ALTER_TABLESPACE_id_SEToRESET))
 		COMPLETE_WITH_CONST("(");
 	/* ALTER TABLESPACE <foo> SET|RESET ( */
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLESPACE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "SET") == 0 ||
-			  pg_strcasecmp(prev2_wd, "RESET") == 0) &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
+	else if (REGMATCH(RE_ALTER_TABLESPACE_id_SEToRESET_))
 	{
 		static const char *const list_TABLESPACEOPTIONS[] =
 		{"seq_page_cost", "random_page_cost", "effective_io_concurrency", NULL};
@@ -1924,20 +1766,14 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* ALTER TEXT SEARCH */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev_wd, "SEARCH") == 0)
+	else if (REGMATCH(RE_ALTER_TEXT_SEARCH))
 	{
 		static const char *const list_ALTERTEXTSEARCH[] =
 		{"CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE", NULL};
 
 		COMPLETE_WITH_LIST(list_ALTERTEXTSEARCH);
 	}
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "SEARCH") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "TEMPLATE") == 0 ||
-			  pg_strcasecmp(prev2_wd, "PARSER") == 0))
+	else if (REGMATCH(RE_ALTER_TEXT_SEARCH_TEMPLATEoPARSER_id))
 	{
 		static const char *const list_ALTERTEXTSEARCH2[] =
 		{"RENAME TO", "SET SCHEMA", NULL};
@@ -1945,10 +1781,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERTEXTSEARCH2);
 	}
 
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "SEARCH") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DICTIONARY") == 0)
+	else if (REGMATCH(RE_ALTER_TEXT_SEARCH_DICTIONARY_id))
 	{
 		static const char *const list_ALTERTEXTSEARCH3[] =
 		{"OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
@@ -1956,10 +1789,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERTEXTSEARCH3);
 	}
 
-	else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "SEARCH") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONFIGURATION") == 0)
+	else if (REGMATCH(RE_ALTER_TEXT_SEARCH_CONFIGURATION_id))
 	{
 		static const char *const list_ALTERTEXTSEARCH4[] =
 		{"ADD MAPPING FOR", "ALTER MAPPING", "DROP MAPPING FOR", "OWNER TO", "RENAME TO", "SET SCHEMA", NULL};
@@ -1968,8 +1798,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* complete ALTER TYPE <foo> with actions */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TYPE") == 0)
+	else if (REGMATCH(RE_ALTER_TYPE_id))
 	{
 		static const char *const list_ALTERTYPE[] =
 		{"ADD ATTRIBUTE", "ADD VALUE", "ALTER ATTRIBUTE", "DROP ATTRIBUTE",
@@ -1978,9 +1807,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERTYPE);
 	}
 	/* complete ALTER TYPE <foo> ADD with actions */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TYPE") == 0 &&
-			 pg_strcasecmp(prev_wd, "ADD") == 0)
+	else if (REGMATCH(RE_ALTER_TYPE_id_ADD))
 	{
 		static const char *const list_ALTERTYPE[] =
 		{"ATTRIBUTE", "VALUE", NULL};
@@ -1988,9 +1815,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERTYPE);
 	}
 	/* ALTER TYPE <foo> RENAME	*/
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TYPE") == 0 &&
-			 pg_strcasecmp(prev_wd, "RENAME") == 0)
+	else if (REGMATCH(RE_ALTER_TYPE_id_RENAME))
 	{
 		static const char *const list_ALTERTYPE[] =
 		{"ATTRIBUTE", "TO", NULL};
@@ -1998,30 +1823,20 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERTYPE);
 	}
 	/* ALTER TYPE xxx RENAME ATTRIBUTE yyy */
-	else if (pg_strcasecmp(prev5_wd, "TYPE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "RENAME") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ATTRIBUTE") == 0)
+	else if (REGMATCH(RE_ALTER_TYPE_id_RENAME_ATTRIBUTE_id))
 		COMPLETE_WITH_CONST("TO");
 
 	/*
 	 * If we have TYPE <sth> ALTER/DROP/RENAME ATTRIBUTE, provide list of
 	 * attributes
 	 */
-	else if (pg_strcasecmp(prev4_wd, "TYPE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "ALTER") == 0 ||
-			  pg_strcasecmp(prev2_wd, "DROP") == 0 ||
-			  pg_strcasecmp(prev2_wd, "RENAME") == 0) &&
-			 pg_strcasecmp(prev_wd, "ATTRIBUTE") == 0)
-		COMPLETE_WITH_ATTR(prev3_wd, "");
+	else if (REGMATCH(RE_ALTER_TYPE_id_ALToDROPoREN_ATTRIBUTE))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 	/* ALTER TYPE ALTER ATTRIBUTE <foo> */
-	else if ((pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			  pg_strcasecmp(prev2_wd, "ATTRIBUTE") == 0))
-	{
+	else if (REGMATCH(RE_ALTER_TYPE_id_ALTER_ATTRIBUTE_id))
 		COMPLETE_WITH_CONST("TYPE");
-	}
 	/* complete ALTER GROUP <foo> */
-	else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "GROUP") == 0)
+	else if (REGMATCH(RE_ALTER_GROUP_id))
 	{
 		static const char *const list_ALTERGROUP[] =
 		{"ADD USER", "DROP USER", "RENAME TO", NULL};
@@ -2029,22 +1844,14 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_ALTERGROUP);
 	}
 	/* complete ALTER GROUP <foo> ADD|DROP with USER */
-	else if (pg_strcasecmp(prev4_wd, "ALTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "GROUP") == 0 &&
-			 (pg_strcasecmp(prev_wd, "ADD") == 0 ||
-			  pg_strcasecmp(prev_wd, "DROP") == 0))
+	else if (REGMATCH(RE_ALTER_GROUP_id_ADDoDROP))
 		COMPLETE_WITH_CONST("USER");
 	/* complete {ALTER} GROUP <foo> ADD|DROP USER with a user name */
-	else if (pg_strcasecmp(prev4_wd, "GROUP") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "ADD") == 0 ||
-			  pg_strcasecmp(prev2_wd, "DROP") == 0) &&
-			 pg_strcasecmp(prev_wd, "USER") == 0)
+	else if (REGMATCH(RE_ALTER_GROUP_id_ADDoDROP_USER))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
 
 /* BEGIN, END, ABORT */
-	else if (pg_strcasecmp(prev_wd, "BEGIN") == 0 ||
-			 pg_strcasecmp(prev_wd, "END") == 0 ||
-			 pg_strcasecmp(prev_wd, "ABORT") == 0)
+	else if (REGMATCH(RE_BEGINoENDoABORT))
 	{
 		static const char *const list_TRANS[] =
 		{"WORK", "TRANSACTION", NULL};
@@ -2052,7 +1859,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_TRANS);
 	}
 /* COMMIT */
-	else if (pg_strcasecmp(prev_wd, "COMMIT") == 0)
+	else if (REGMATCH(RE_COMMIT))
 	{
 		static const char *const list_COMMIT[] =
 		{"WORK", "TRANSACTION", "PREPARED", NULL};
@@ -2060,10 +1867,10 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_COMMIT);
 	}
 /* RELEASE SAVEPOINT */
-	else if (pg_strcasecmp(prev_wd, "RELEASE") == 0)
+	else if (REGMATCH(RE_RELEASE))
 		COMPLETE_WITH_CONST("SAVEPOINT");
 /* ROLLBACK*/
-	else if (pg_strcasecmp(prev_wd, "ROLLBACK") == 0)
+	else if (REGMATCH(RE_ROLLBACK))
 	{
 		static const char *const list_TRANS[] =
 		{"WORK", "TRANSACTION", "TO SAVEPOINT", "PREPARED", NULL};
@@ -2075,57 +1882,38 @@ psql_completion(const char *text, int start, int end)
 	/*
 	 * If the previous word is CLUSTER and not WITHOUT produce list of tables
 	 */
-	else if (pg_strcasecmp(prev_wd, "CLUSTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "WITHOUT") != 0)
+	else if (REGMATCH(RE_CLUSTER))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm, "UNION SELECT 'VERBOSE'");
 
 	/*
 	 * If the previous words are CLUSTER VERBOSE produce list of tables
 	 */
-	else if (pg_strcasecmp(prev_wd, "VERBOSE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CLUSTER") == 0)
+	else if (REGMATCH(RE_CLUSTER_VERBOSE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm, NULL);
 
 	/* If we have CLUSTER <sth>, then add "USING" */
-	else if (pg_strcasecmp(prev2_wd, "CLUSTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") != 0 &&
-			 pg_strcasecmp(prev_wd, "VERBOSE") != 0)
-	{
+	else if (REGMATCH(RE_CLUSTER_negONoVERBOSE))
 		COMPLETE_WITH_CONST("USING");
-	}
-	/* If we have CLUSTER VERBOSE <sth>, then add "USING" */
-	else if (pg_strcasecmp(prev3_wd, "CLUSTER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VERBOSE") == 0)
-	{
+	else if (REGMATCH(RE_CLUSTER_VERBOSE_id))
 		COMPLETE_WITH_CONST("USING");
-	}
-
 	/*
 	 * If we have CLUSTER <sth> USING, then add the index as well.
 	 */
-	else if (pg_strcasecmp(prev3_wd, "CLUSTER") == 0 &&
-			 pg_strcasecmp(prev_wd, "USING") == 0)
+	else if (REGMATCH(RE_CLUSTER_id_USING))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_index_of_table);
 	}
-
-	/*
-	 * If we have CLUSTER VERBOSE <sth> USING, then add the index as well.
-	 */
-	else if (pg_strcasecmp(prev4_wd, "CLUSTER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "VERBOSE") == 0 &&
-			 pg_strcasecmp(prev_wd, "USING") == 0)
+	else if (REGMATCH(RE_CLUSTER_VERBOSE_id_USING))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_index_of_table);
 	}
 
 /* COMMENT */
-	else if (pg_strcasecmp(prev_wd, "COMMENT") == 0)
+	else if (REGMATCH(RE_COMMENT))
 		COMPLETE_WITH_CONST("ON");
-	else if (pg_strcasecmp(prev2_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_COMMENT_ON))
 	{
 		static const char *const list_COMMENT[] =
 		{"CAST", "COLLATION", "CONVERSION", "DATABASE", "EVENT TRIGGER", "EXTENSION",
@@ -2137,66 +1925,34 @@ psql_completion(const char *text, int start, int end)
 
 		COMPLETE_WITH_LIST(list_COMMENT);
 	}
-	else if (pg_strcasecmp(prev3_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOREIGN") == 0)
+	else if (REGMATCH(RE_COMMENT_ON_FOREIGN))
 	{
 		static const char *const list_TRANS2[] =
 		{"DATA WRAPPER", "TABLE", NULL};
 
 		COMPLETE_WITH_LIST(list_TRANS2);
 	}
-	else if (pg_strcasecmp(prev4_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev_wd, "SEARCH") == 0)
+	else if (REGMATCH(RE_COMMENT_ON_TEXT_SEARCH))
 	{
 		static const char *const list_TRANS2[] =
 		{"CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE", NULL};
 
 		COMPLETE_WITH_LIST(list_TRANS2);
 	}
-	else if (pg_strcasecmp(prev3_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "CONSTRAINT") == 0)
-	{
+	else if (REGMATCH(RE_COMMENT_ON_CONSTRAINT))
 		COMPLETE_WITH_QUERY(Query_for_all_table_constraints);
-	}
-	else if (pg_strcasecmp(prev4_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONSTRAINT") == 0)
-	{
+	else if (REGMATCH(RE_COMMENT_ON_CONSTRAINT_id))
 		COMPLETE_WITH_CONST("ON");
-	}
-	else if (pg_strcasecmp(prev5_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev3_wd, "CONSTRAINT") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_COMMENT_ON_CONSTRAINT_id_ON))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_constraint);
 	}
-	else if (pg_strcasecmp(prev4_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev_wd, "VIEW") == 0)
-	{
+	else if (REGMATCH(RE_COMMENT_ON_MATERIALIZED_VIEW))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews, NULL);
-	}
-	else if (pg_strcasecmp(prev4_wd, "COMMENT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev_wd, "TRIGGER") == 0)
-	{
+	else if (REGMATCH(RE_COMMENT_ON_EVENT_TRIGGER))
 		COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
-	}
-	else if (((pg_strcasecmp(prev4_wd, "COMMENT") == 0 &&
-			   pg_strcasecmp(prev3_wd, "ON") == 0) ||
-			  (pg_strcasecmp(prev5_wd, "COMMENT") == 0 &&
-			   pg_strcasecmp(prev4_wd, "ON") == 0) ||
-			  (pg_strcasecmp(prev6_wd, "COMMENT") == 0 &&
-			   pg_strcasecmp(prev5_wd, "ON") == 0)) &&
-			 pg_strcasecmp(prev_wd, "IS") != 0)
+	else if (REGMATCH(RE_COMMENT_ON_any_negIS))
 		COMPLETE_WITH_CONST("IS");
 
 /* COPY */
@@ -2205,15 +1961,10 @@ psql_completion(const char *text, int start, int end)
 	 * If we have COPY [BINARY] (which you'd have to type yourself), offer
 	 * list of tables (Also cover the analogous backslash command)
 	 */
-	else if (pg_strcasecmp(prev_wd, "COPY") == 0 ||
-			 pg_strcasecmp(prev_wd, "\\copy") == 0 ||
-			 (pg_strcasecmp(prev2_wd, "COPY") == 0 &&
-			  pg_strcasecmp(prev_wd, "BINARY") == 0))
+	else if (REGMATCH(RE_COPY_oBINARY))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
 	/* If we have COPY|BINARY <sth>, complete it with "TO" or "FROM" */
-	else if (pg_strcasecmp(prev2_wd, "COPY") == 0 ||
-			 pg_strcasecmp(prev2_wd, "\\copy") == 0 ||
-			 pg_strcasecmp(prev2_wd, "BINARY") == 0)
+	else if (REGMATCH(RE_COPY_oBINARY_id))
 	{
 		static const char *const list_FROMTO[] =
 		{"FROM", "TO", NULL};
@@ -2221,22 +1972,14 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_FROMTO);
 	}
 	/* If we have COPY|BINARY <sth> FROM|TO, complete with filename */
-	else if ((pg_strcasecmp(prev3_wd, "COPY") == 0 ||
-			  pg_strcasecmp(prev3_wd, "\\copy") == 0 ||
-			  pg_strcasecmp(prev3_wd, "BINARY") == 0) &&
-			 (pg_strcasecmp(prev_wd, "FROM") == 0 ||
-			  pg_strcasecmp(prev_wd, "TO") == 0))
+	else if (REGMATCH(RE_COPY_oBINARY_id_FROMoTO))
 	{
 		completion_charp = "";
 		matches = completion_matches(text, complete_from_files);
 	}
 
 	/* Handle COPY|BINARY <sth> FROM|TO filename */
-	else if ((pg_strcasecmp(prev4_wd, "COPY") == 0 ||
-			  pg_strcasecmp(prev4_wd, "\\copy") == 0 ||
-			  pg_strcasecmp(prev4_wd, "BINARY") == 0) &&
-			 (pg_strcasecmp(prev2_wd, "FROM") == 0 ||
-			  pg_strcasecmp(prev2_wd, "TO") == 0))
+	else if (REGMATCH(RE_COPY_oBINARY_id_FROMoTO_any))
 	{
 		static const char *const list_COPY[] =
 		{"BINARY", "OIDS", "DELIMITER", "NULL", "CSV", "ENCODING", NULL};
@@ -2245,9 +1988,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* Handle COPY|BINARY <sth> FROM|TO filename CSV */
-	else if (pg_strcasecmp(prev_wd, "CSV") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "FROM") == 0 ||
-			  pg_strcasecmp(prev3_wd, "TO") == 0))
+	else if (REGMATCH(RE_COPY_any_FROMoTO_any_CSV))
 	{
 		static const char *const list_CSV[] =
 		{"HEADER", "QUOTE", "ESCAPE", "FORCE QUOTE", "FORCE NOT NULL", NULL};
@@ -2255,9 +1996,8 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CSV);
 	}
 
-	/* CREATE DATABASE */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DATABASE") == 0)
+	/* CREATE DATABASE <name> */
+	else if (REGMATCH(RE_CREATE_DATABASE_id))
 	{
 		static const char *const list_DATABASE[] =
 		{"OWNER", "TEMPLATE", "ENCODING", "TABLESPACE", "IS_TEMPLATE",
@@ -2267,19 +2007,15 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_DATABASE);
 	}
 
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DATABASE") == 0 &&
-			 pg_strcasecmp(prev_wd, "TEMPLATE") == 0)
+	else if (REGMATCH(RE_CREATE_DATABASE_id_TEMPLATE))
 		COMPLETE_WITH_QUERY(Query_for_list_of_template_databases);
 
 	/* CREATE EXTENSION */
 	/* Complete with available extensions rather than installed ones. */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev_wd, "EXTENSION") == 0)
+	else if (REGMATCH(RE_CREATE_EXTENSION))
 		COMPLETE_WITH_QUERY(Query_for_list_of_available_extensions);
 	/* CREATE EXTENSION <name> */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "EXTENSION") == 0)
+	else if (REGMATCH(RE_CREATE_EXTENSION_id))
 	{
 		static const char *const list_CREATE_EXTENSION[] =
 		{"WITH SCHEMA", "CASCADE", "VERSION", NULL};
@@ -2287,17 +2023,14 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATE_EXTENSION);
 	}
 	/* CREATE EXTENSION <name> VERSION */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "EXTENSION") == 0 &&
-			 pg_strcasecmp(prev_wd, "VERSION") == 0)
+	else if (REGMATCH(RE_CREATE_EXTENSION_id_VERSION))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions);
 	}
 
 	/* CREATE FOREIGN */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOREIGN") == 0)
+	else if (REGMATCH(RE_CREATE_FOREIGN))
 	{
 		static const char *const list_CREATE_FOREIGN[] =
 		{"DATA WRAPPER", "TABLE", NULL};
@@ -2306,10 +2039,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* CREATE FOREIGN DATA WRAPPER */
-	else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DATA") == 0 &&
-			 pg_strcasecmp(prev2_wd, "WRAPPER") == 0)
+	else if (REGMATCH(RE_CREATE_FOREIGN_DATA_WRAPPER_id))
 	{
 		static const char *const list_CREATE_FOREIGN_DATA_WRAPPER[] =
 		{"HANDLER", "VALIDATOR", NULL};
@@ -2319,31 +2049,21 @@ psql_completion(const char *text, int start, int end)
 
 	/* CREATE INDEX */
 	/* First off we complete CREATE UNIQUE with "INDEX" */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev_wd, "UNIQUE") == 0)
+	else if (REGMATCH(RE_CREATE_UNIQUE))
 		COMPLETE_WITH_CONST("INDEX");
 	/* If we have CREATE|UNIQUE INDEX, then add "ON" and existing indexes */
-	else if (pg_strcasecmp(prev_wd, "INDEX") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "CREATE") == 0 ||
-			  pg_strcasecmp(prev2_wd, "UNIQUE") == 0))
+	else if (REGMATCH(RE_CREATE_oUNIQUE_INDEX))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes,
 								   " UNION SELECT 'ON'"
 								   " UNION SELECT 'CONCURRENTLY'");
 	/* Complete ... INDEX [<name>] ON with a list of tables  */
-	else if ((pg_strcasecmp(prev3_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev2_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev2_wd, "CONCURRENTLY") == 0) &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_INDEX_oname_CONCURRENTLY_ON))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm, NULL);
 	/* If we have CREATE|UNIQUE INDEX <sth> CONCURRENTLY, then add "ON" */
-	else if ((pg_strcasecmp(prev3_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev2_wd, "INDEX") == 0) &&
-			 pg_strcasecmp(prev_wd, "CONCURRENTLY") == 0)
+	else if (REGMATCH(RE_INDEX_oname_CONCURRENTLY))
 		COMPLETE_WITH_CONST("ON");
 	/* If we have CREATE|UNIQUE INDEX <sth>, then add "ON" or "CONCURRENTLY" */
-	else if ((pg_strcasecmp(prev3_wd, "CREATE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "UNIQUE") == 0) &&
-			 pg_strcasecmp(prev2_wd, "INDEX") == 0)
+	else if (REGMATCH(RE_CREATE_oUNIQUE_INDEX_name))
 	{
 		static const char *const list_CREATE_INDEX[] =
 		{"CONCURRENTLY", "ON", NULL};
@@ -2355,54 +2075,33 @@ psql_completion(const char *text, int start, int end)
 	 * Complete INDEX <name> ON <table> with a list of table columns (which
 	 * should really be in parens)
 	 */
-	else if ((pg_strcasecmp(prev4_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev3_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev3_wd, "CONCURRENTLY") == 0) &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_INDEX_oname_CONCURRENTLY_ON_id))
 	{
 		static const char *const list_CREATE_INDEX2[] =
 		{"(", "USING", NULL};
 
 		COMPLETE_WITH_LIST(list_CREATE_INDEX2);
 	}
-	else if ((pg_strcasecmp(prev5_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev4_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev4_wd, "CONCURRENTLY") == 0) &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
-		COMPLETE_WITH_ATTR(prev2_wd, "");
+	else if (REGMATCH(RE_INDEX_oname_CONCURRENTLY_ON_id_))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 	/* same if you put in USING */
-	else if (pg_strcasecmp(prev5_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev3_wd, "USING") == 0 &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
-		COMPLETE_WITH_ATTR(prev4_wd, "");
+	else if (REGMATCH(RE_ON_id_USING_kwd_))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 	/* Complete USING with an index method */
-	else if ((pg_strcasecmp(prev6_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev5_wd, "INDEX") == 0 ||
-			  pg_strcasecmp(prev4_wd, "INDEX") == 0) &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "USING") == 0)
+	else if (REGMATCH(RE_ON_id_USING))
 		COMPLETE_WITH_QUERY(Query_for_list_of_access_methods);
-	else if (pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 (!(pg_strcasecmp(prev6_wd, "POLICY") == 0) &&
-			  !(pg_strcasecmp(prev4_wd, "FOR") == 0)) &&
-			 pg_strcasecmp(prev2_wd, "USING") == 0)
+	else if (REGMATCH(RE_CREATE_INDEX_any_ON_id_USING_kwd))
 		COMPLETE_WITH_CONST("(");
 
 	/* CREATE POLICY */
 	/* Complete "CREATE POLICY <name> ON" */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "POLICY") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id))
 		COMPLETE_WITH_CONST("ON");
 	/* Complete "CREATE POLICY <name> ON <table>" */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
 	/* Complete "CREATE POLICY <name> ON <table> FOR|TO|USING|WITH CHECK" */
-	else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev4_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id))
 	{
 		static const char *const list_POLICYOPTIONS[] =
 		{"FOR", "TO", "USING", "WITH CHECK", NULL};
@@ -2414,10 +2113,7 @@ psql_completion(const char *text, int start, int end)
 	 * Complete "CREATE POLICY <name> ON <table> FOR
 	 * ALL|SELECT|INSERT|UPDATE|DELETE"
 	 */
-	else if (pg_strcasecmp(prev6_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev5_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOR") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id_FOR))
 	{
 		static const char *const list_POLICYCMDS[] =
 		{"ALL", "SELECT", "INSERT", "UPDATE", "DELETE", NULL};
@@ -2425,10 +2121,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_POLICYCMDS);
 	}
 	/* Complete "CREATE POLICY <name> ON <table> FOR INSERT TO|WITH CHECK" */
-	else if (pg_strcasecmp(prev6_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "FOR") == 0 &&
-			 pg_strcasecmp(prev_wd, "INSERT") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id_FOR_INSERT))
 	{
 		static const char *const list_POLICYOPTIONS[] =
 		{"TO", "WITH CHECK", NULL};
@@ -2440,11 +2133,7 @@ psql_completion(const char *text, int start, int end)
 	 * Complete "CREATE POLICY <name> ON <table> FOR SELECT TO|USING" Complete
 	 * "CREATE POLICY <name> ON <table> FOR DELETE TO|USING"
 	 */
-	else if (pg_strcasecmp(prev6_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "FOR") == 0 &&
-			 (pg_strcasecmp(prev_wd, "SELECT") == 0 ||
-			  pg_strcasecmp(prev_wd, "DELETE") == 0))
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id_FOR_SELoDEL))
 	{
 		static const char *const list_POLICYOPTIONS[] =
 		{"TO", "USING", NULL};
@@ -2457,11 +2146,7 @@ psql_completion(const char *text, int start, int end)
 	 * Complete "CREATE POLICY <name> ON <table> FOR UPDATE TO|USING|WITH
 	 * CHECK"
 	 */
-	else if (pg_strcasecmp(prev6_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev2_wd, "FOR") == 0 &&
-			 (pg_strcasecmp(prev_wd, "ALL") == 0 ||
-			  pg_strcasecmp(prev_wd, "UPDATE") == 0))
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id_FOR_UPDATE))
 	{
 		static const char *const list_POLICYOPTIONS[] =
 		{"TO", "USING", "WITH CHECK", NULL};
@@ -2469,32 +2154,21 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_POLICYOPTIONS);
 	}
 	/* Complete "CREATE POLICY <name> ON <table> TO <role>" */
-	else if (pg_strcasecmp(prev6_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev5_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "TO") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id_TO))
 		COMPLETE_WITH_QUERY(Query_for_list_of_grant_roles);
 	/* Complete "CREATE POLICY <name> ON <table> USING (" */
-	else if (pg_strcasecmp(prev6_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev5_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "USING") == 0)
+	else if (REGMATCH(RE_CREATE_POLICY_id_ON_id_USING))
 		COMPLETE_WITH_CONST("(");
 
 /* CREATE RULE */
 	/* Complete "CREATE RULE <sth>" with "AS" */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "RULE") == 0)
+	else if (REGMATCH(RE_CREATE_RULE_id))
 		COMPLETE_WITH_CONST("AS");
 	/* Complete "CREATE RULE <sth> AS with "ON" */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "RULE") == 0 &&
-			 pg_strcasecmp(prev_wd, "AS") == 0)
+	else if (REGMATCH(RE_CREATE_RULE_id_AS))
 		COMPLETE_WITH_CONST("ON");
 	/* Complete "RULE * AS ON" with SELECT|UPDATE|DELETE|INSERT */
-	else if (pg_strcasecmp(prev4_wd, "RULE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "AS") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_CREATE_RULE_id_AS_ON))
 	{
 		static const char *const rule_events[] =
 		{"SELECT", "UPDATE", "INSERT", "DELETE", NULL};
@@ -2502,24 +2176,14 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(rule_events);
 	}
 	/* Complete "AS ON <sth with a 'T' :)>" with a "TO" */
-	else if (pg_strcasecmp(prev3_wd, "AS") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0 &&
-			 (pg_toupper((unsigned char) prev_wd[4]) == 'T' ||
-			  pg_toupper((unsigned char) prev_wd[5]) == 'T'))
+	else if (REGMATCH(RE_CREATE_RULE_id_AS_ON_event))
 		COMPLETE_WITH_CONST("TO");
 	/* Complete "AS ON <sth> TO" with a table name */
-	else if (pg_strcasecmp(prev4_wd, "AS") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "TO") == 0)
+	else if (REGMATCH(RE_CREATE_RULE_id_AS_ON_event_TO))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
 
 /* CREATE TEMP/TEMPORARY SEQUENCE <name> */
-	else if ((pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			  pg_strcasecmp(prev2_wd, "SEQUENCE") == 0) ||
-			 (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			  (pg_strcasecmp(prev3_wd, "TEMP") == 0 ||
-			   pg_strcasecmp(prev3_wd, "TEMPORARY") == 0) &&
-			  pg_strcasecmp(prev2_wd, "SEQUENCE") == 0))
+	else if (REGMATCH(RE_CREATE_oTEMP_SEQUENCE_oINE_id))
 	{
 		static const char *const list_CREATESEQUENCE[] =
 		{"INCREMENT BY", "MINVALUE", "MAXVALUE", "NO", "CACHE",
@@ -2528,13 +2192,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATESEQUENCE);
 	}
 /* CREATE TEMP/TEMPORARY SEQUENCE <name> NO */
-	else if (((pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			  pg_strcasecmp(prev3_wd, "SEQUENCE") == 0) ||
-			 (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			  (pg_strcasecmp(prev4_wd, "TEMP") == 0 ||
-			   pg_strcasecmp(prev4_wd, "TEMPORARY") == 0) &&
-			  pg_strcasecmp(prev3_wd, "SEQUENCE") == 0)) &&
-			 pg_strcasecmp(prev_wd, "NO") == 0)
+	else if (REGMATCH(RE_CREATE_oTEMP_SEQUENCE_oINE_id_any_NO))
 	{
 		static const char *const list_CREATESEQUENCE2[] =
 		{"MINVALUE", "MAXVALUE", "CYCLE", NULL};
@@ -2543,8 +2201,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* CREATE SERVER <name> */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SERVER") == 0)
+	else if (REGMATCH(RE_CREATE_SERVER_id))
 	{
 		static const char *const list_CREATE_SERVER[] =
 		{"TYPE", "VERSION", "FOREIGN DATA WRAPPER", NULL};
@@ -2554,9 +2211,7 @@ psql_completion(const char *text, int start, int end)
 
 /* CREATE TABLE */
 	/* Complete "CREATE TEMP/TEMPORARY" with the possible temp objects */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 (pg_strcasecmp(prev_wd, "TEMP") == 0 ||
-			  pg_strcasecmp(prev_wd, "TEMPORARY") == 0))
+	else if (REGMATCH(RE_CREATE_TEMP))
 	{
 		static const char *const list_TEMP[] =
 		{"SEQUENCE", "TABLE", "VIEW", NULL};
@@ -2564,8 +2219,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_TEMP);
 	}
 	/* Complete "CREATE UNLOGGED" with TABLE */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev_wd, "UNLOGGED") == 0)
+	else if (REGMATCH(RE_CREATE_UNLOGGED))
 	{
 		static const char *const list_UNLOGGED[] =
 		{"TABLE", "MATERIALIZED VIEW", NULL};
@@ -2574,8 +2228,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* CREATE TABLESPACE */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TABLESPACE") == 0)
+	else if (REGMATCH(RE_CREATE_TABLESPACE_id))
 	{
 		static const char *const list_CREATETABLESPACE[] =
 		{"OWNER", "LOCATION", NULL};
@@ -2583,32 +2236,25 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATETABLESPACE);
 	}
 	/* Complete CREATE TABLESPACE name OWNER name with "LOCATION" */
-	else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TABLESPACE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "OWNER") == 0)
+	else if (REGMATCH(RE_CREATE_TABLESPACE_id_OWNER_id))
 	{
 		COMPLETE_WITH_CONST("LOCATION");
 	}
 
 /* CREATE TEXT SEARCH */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev_wd, "SEARCH") == 0)
+	else if (REGMATCH(RE_CREATE_TEXT_SEARCH))
 	{
 		static const char *const list_CREATETEXTSEARCH[] =
 		{"CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE", NULL};
 
 		COMPLETE_WITH_LIST(list_CREATETEXTSEARCH);
 	}
-	else if (pg_strcasecmp(prev4_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "SEARCH") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONFIGURATION") == 0)
+	else if (REGMATCH(RE_CREATE_TEXT_SEARCH_CONFIGURATION_id))
 		COMPLETE_WITH_CONST("(");
 
 /* CREATE TRIGGER */
 	/* complete CREATE TRIGGER <name> with BEFORE,AFTER */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_CREATE_TRIGGER_id))
 	{
 		static const char *const list_CREATETRIGGER[] =
 		{"BEFORE", "AFTER", "INSTEAD OF", NULL};
@@ -2616,10 +2262,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATETRIGGER);
 	}
 	/* complete CREATE TRIGGER <name> BEFORE,AFTER with an event */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TRIGGER") == 0 &&
-			 (pg_strcasecmp(prev_wd, "BEFORE") == 0 ||
-			  pg_strcasecmp(prev_wd, "AFTER") == 0))
+	else if (REGMATCH(RE_CREATE_TRIGGER_id_BEFoAFT))
 	{
 		static const char *const list_CREATETRIGGER_EVENTS[] =
 		{"INSERT", "DELETE", "UPDATE", "TRUNCATE", NULL};
@@ -2627,10 +2270,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATETRIGGER_EVENTS);
 	}
 	/* complete CREATE TRIGGER <name> INSTEAD OF with an event */
-	else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "INSTEAD") == 0 &&
-			 pg_strcasecmp(prev_wd, "OF") == 0)
+	else if (REGMATCH(RE_CREATE_TRIGGER_id_INSTEAD_OF))
 	{
 		static const char *const list_CREATETRIGGER_EVENTS[] =
 		{"INSERT", "DELETE", "UPDATE", NULL};
@@ -2638,13 +2278,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATETRIGGER_EVENTS);
 	}
 	/* complete CREATE TRIGGER <name> BEFORE,AFTER sth with OR,ON */
-	else if ((pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			  pg_strcasecmp(prev4_wd, "TRIGGER") == 0 &&
-			  (pg_strcasecmp(prev2_wd, "BEFORE") == 0 ||
-			   pg_strcasecmp(prev2_wd, "AFTER") == 0)) ||
-			 (pg_strcasecmp(prev5_wd, "TRIGGER") == 0 &&
-			  pg_strcasecmp(prev3_wd, "INSTEAD") == 0 &&
-			  pg_strcasecmp(prev2_wd, "OF") == 0))
+	else if (REGMATCH(RE_CREATE_TRIGGER_id_BEFoAFToINSOF_events))
 	{
 		static const char *const list_CREATETRIGGER2[] =
 		{"ON", "OR", NULL};
@@ -2656,27 +2290,14 @@ psql_completion(const char *text, int start, int end)
 	 * complete CREATE TRIGGER <name> BEFORE,AFTER event ON with a list of
 	 * tables
 	 */
-	else if (pg_strcasecmp(prev5_wd, "TRIGGER") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "BEFORE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "AFTER") == 0) &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_CREATE_TRIGGER_id_BEFoAFToINSOF_events_ON))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
-	/* complete CREATE TRIGGER ... INSTEAD OF event ON with a list of views */
-	else if (pg_strcasecmp(prev4_wd, "INSTEAD") == 0 &&
-			 pg_strcasecmp(prev3_wd, "OF") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
-		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views, NULL);
 	/* complete CREATE TRIGGER ... EXECUTE with PROCEDURE */
-	else if (pg_strcasecmp(prev_wd, "EXECUTE") == 0 &&
-			 !(pg_strcasecmp(prev2_wd, "GRANT") == 0 && prev3_wd[0] == '\0') &&
-			 prev2_wd[0] != '\0')
+	else if (REGMATCH(RE_CREATE_TRIGGER_id_any_EXECUTE))
 		COMPLETE_WITH_CONST("PROCEDURE");
 
 /* CREATE ROLE,USER,GROUP <name> */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 !(pg_strcasecmp(prev2_wd, "USER") == 0 && pg_strcasecmp(prev_wd, "MAPPING") == 0) &&
-			 (pg_strcasecmp(prev2_wd, "ROLE") == 0 ||
-			  pg_strcasecmp(prev2_wd, "GROUP") == 0 || pg_strcasecmp(prev2_wd, "USER") == 0))
+	else if (REGMATCH(RE_CREATE_USERoROLEoGROUP_id))
 	{
 		static const char *const list_CREATEROLE[] =
 		{"ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE",
@@ -2688,13 +2309,8 @@ psql_completion(const char *text, int start, int end)
 
 		COMPLETE_WITH_LIST(list_CREATEROLE);
 	}
-
-/* CREATE ROLE,USER,GROUP <name> WITH */
-	else if ((pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			  (pg_strcasecmp(prev3_wd, "ROLE") == 0 ||
-			   pg_strcasecmp(prev3_wd, "GROUP") == 0 ||
-			   pg_strcasecmp(prev3_wd, "USER") == 0) &&
-			  pg_strcasecmp(prev_wd, "WITH") == 0))
+	/* Successive options */
+	else if (REGMATCH(RE_CREATE_USERoROLEoGROUP_id_WITH))
 	{
 		/* Similar to the above, but don't complete "WITH" again. */
 		static const char *const list_CREATEROLE_WITH[] =
@@ -2707,23 +2323,14 @@ psql_completion(const char *text, int start, int end)
 
 		COMPLETE_WITH_LIST(list_CREATEROLE_WITH);
 	}
-
 	/*
 	 * complete CREATE ROLE,USER,GROUP <name> ENCRYPTED,UNENCRYPTED with
 	 * PASSWORD
 	 */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "ROLE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "GROUP") == 0 || pg_strcasecmp(prev3_wd, "USER") == 0) &&
-			 (pg_strcasecmp(prev_wd, "ENCRYPTED") == 0 || pg_strcasecmp(prev_wd, "UNENCRYPTED") == 0))
-	{
+	else if (REGMATCH(RE_CREATE_USERoROLEoGROUP_id_ENCoUNENC))
 		COMPLETE_WITH_CONST("PASSWORD");
-	}
 	/* complete CREATE ROLE,USER,GROUP <name> IN with ROLE,GROUP */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "ROLE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "GROUP") == 0 || pg_strcasecmp(prev3_wd, "USER") == 0) &&
-			 pg_strcasecmp(prev_wd, "IN") == 0)
+	else if (REGMATCH(RE_CREATE_USERoROLEoGROUP_id_IN))
 	{
 		static const char *const list_CREATEROLE3[] =
 		{"GROUP", "ROLE", NULL};
@@ -2731,47 +2338,33 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_CREATEROLE3);
 	}
 
+
 /* CREATE VIEW */
 	/* Complete CREATE VIEW <name> with AS */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VIEW") == 0)
+	else if (REGMATCH(RE_CREATE_VIEW_id))
 		COMPLETE_WITH_CONST("AS");
 	/* Complete "CREATE VIEW <sth> AS with "SELECT" */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev_wd, "AS") == 0)
+	else if (REGMATCH(RE_CREATE_VIEW_id_AS))
 		COMPLETE_WITH_CONST("SELECT");
 
 /* CREATE MATERIALIZED VIEW */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev_wd, "MATERIALIZED") == 0)
+	else if (REGMATCH(RE_CREATE_MATERIALIZED))
 		COMPLETE_WITH_CONST("VIEW");
 	/* Complete CREATE MATERIALIZED VIEW <name> with AS */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VIEW") == 0)
+	else if (REGMATCH(RE_CREATE_MATVIEW_id))
 		COMPLETE_WITH_CONST("AS");
 	/* Complete "CREATE MATERIALIZED VIEW <sth> AS with "SELECT" */
-	else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev4_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev3_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev_wd, "AS") == 0)
+	else if (REGMATCH(RE_CREATE_MATVIEW_id_any_AS))
 		COMPLETE_WITH_CONST("SELECT");
 
 /* CREATE EVENT TRIGGER */
-	else if (pg_strcasecmp(prev2_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev_wd, "EVENT") == 0)
+	else if (REGMATCH(RE_CREATE_EVENT))
 		COMPLETE_WITH_CONST("TRIGGER");
 	/* Complete CREATE EVENT TRIGGER <name> with ON */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TRIGGER") == 0)
+	else if (REGMATCH(RE_CREATE_EVENT_TRIGGER_id))
 		COMPLETE_WITH_CONST("ON");
 	/* Complete CREATE EVENT TRIGGER <name> ON with event_type */
-	else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev4_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_CREATE_EVENT_TRIGGER_id_ON))
 	{
 		static const char *const list_CREATE_EVENT_TRIGGER_ON[] =
 		{"ddl_command_start", "ddl_command_end", "sql_drop", NULL};
@@ -2780,7 +2373,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* DECLARE */
-	else if (pg_strcasecmp(prev2_wd, "DECLARE") == 0)
+	else if (REGMATCH(RE_DECLARE_id))
 	{
 		static const char *const list_DECLARE[] =
 		{"BINARY", "INSENSITIVE", "SCROLL", "NO SCROLL", "CURSOR", NULL};
@@ -2789,7 +2382,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* CURSOR */
-	else if (pg_strcasecmp(prev_wd, "CURSOR") == 0)
+	else if (REGMATCH(RE_DECLARE_id_oBIN_oINSEN_oNOSCR_CURSOR))
 	{
 		static const char *const list_DECLARECURSOR[] =
 		{"WITH HOLD", "WITHOUT HOLD", "FOR", NULL};
@@ -2804,19 +2397,13 @@ psql_completion(const char *text, int start, int end)
 	 * Complete DELETE with FROM (only if the word before that is not "ON"
 	 * (cf. rules) or "BEFORE" or "AFTER" (cf. triggers) or GRANT)
 	 */
-	else if (pg_strcasecmp(prev_wd, "DELETE") == 0 &&
-			 !(pg_strcasecmp(prev2_wd, "ON") == 0 ||
-			   pg_strcasecmp(prev2_wd, "GRANT") == 0 ||
-			   pg_strcasecmp(prev2_wd, "BEFORE") == 0 ||
-			   pg_strcasecmp(prev2_wd, "AFTER") == 0))
+	else if (REGMATCH(RE_DELETE))
 		COMPLETE_WITH_CONST("FROM");
 	/* Complete DELETE FROM with a list of tables */
-	else if (pg_strcasecmp(prev2_wd, "DELETE") == 0 &&
-			 pg_strcasecmp(prev_wd, "FROM") == 0)
+	else if (REGMATCH(RE_DELETE_FROM))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables, NULL);
 	/* Complete DELETE FROM <table> */
-	else if (pg_strcasecmp(prev3_wd, "DELETE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "FROM") == 0)
+	else if (REGMATCH(RE_DELETE_FROM_id))
 	{
 		static const char *const list_DELETE[] =
 		{"USING", "WHERE", "SET", NULL};
@@ -2826,7 +2413,7 @@ psql_completion(const char *text, int start, int end)
 	/* XXX: implement tab completion for DELETE ... USING */
 
 /* DISCARD */
-	else if (pg_strcasecmp(prev_wd, "DISCARD") == 0)
+	else if (REGMATCH(RE_DISCARD))
 	{
 		static const char *const list_DISCARD[] =
 		{"ALL", "PLANS", "SEQUENCES", "TEMP", NULL};
@@ -2839,7 +2426,7 @@ psql_completion(const char *text, int start, int end)
 	/*
 	 * Complete DO with LANGUAGE.
 	 */
-	else if (pg_strcasecmp(prev_wd, "DO") == 0)
+	else if (REGMATCH(RE_DO))
 	{
 		static const char *const list_DO[] =
 		{"LANGUAGE", NULL};
@@ -2849,49 +2436,16 @@ psql_completion(const char *text, int start, int end)
 
 /* DROP (when not the previous word) */
 	/* DROP AGGREGATE */
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "AGGREGATE") == 0)
+	else if (REGMATCH(RE_DROP_AGGREGATE_id))
 		COMPLETE_WITH_CONST("(");
 
 	/* DROP object with CASCADE / RESTRICT */
-	else if ((pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			  (pg_strcasecmp(prev2_wd, "COLLATION") == 0 ||
-			   pg_strcasecmp(prev2_wd, "CONVERSION") == 0 ||
-			   pg_strcasecmp(prev2_wd, "DOMAIN") == 0 ||
-			   pg_strcasecmp(prev2_wd, "EXTENSION") == 0 ||
-			   pg_strcasecmp(prev2_wd, "FUNCTION") == 0 ||
-			   pg_strcasecmp(prev2_wd, "INDEX") == 0 ||
-			   pg_strcasecmp(prev2_wd, "LANGUAGE") == 0 ||
-			   pg_strcasecmp(prev2_wd, "SCHEMA") == 0 ||
-			   pg_strcasecmp(prev2_wd, "SEQUENCE") == 0 ||
-			   pg_strcasecmp(prev2_wd, "SERVER") == 0 ||
-			   pg_strcasecmp(prev2_wd, "TABLE") == 0 ||
-			   pg_strcasecmp(prev2_wd, "TYPE") == 0 ||
-			   pg_strcasecmp(prev2_wd, "VIEW") == 0)) ||
-			 (pg_strcasecmp(prev4_wd, "DROP") == 0 &&
-			  pg_strcasecmp(prev3_wd, "AGGREGATE") == 0 &&
-			  prev_wd[strlen(prev_wd) - 1] == ')') ||
-			 (pg_strcasecmp(prev4_wd, "DROP") == 0 &&
-			  pg_strcasecmp(prev3_wd, "EVENT") == 0 &&
-			  pg_strcasecmp(prev2_wd, "TRIGGER") == 0) ||
-			 (pg_strcasecmp(prev5_wd, "DROP") == 0 &&
-			  pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
-			  pg_strcasecmp(prev3_wd, "DATA") == 0 &&
-			  pg_strcasecmp(prev2_wd, "WRAPPER") == 0) ||
-			 (pg_strcasecmp(prev5_wd, "DROP") == 0 &&
-			  pg_strcasecmp(prev4_wd, "TEXT") == 0 &&
-			  pg_strcasecmp(prev3_wd, "SEARCH") == 0 &&
-			  (pg_strcasecmp(prev2_wd, "CONFIGURATION") == 0 ||
-			   pg_strcasecmp(prev2_wd, "DICTIONARY") == 0 ||
-			   pg_strcasecmp(prev2_wd, "PARSER") == 0 ||
-			   pg_strcasecmp(prev2_wd, "TEMPLATE") == 0))
-		)
-	{
-		if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			pg_strcasecmp(prev2_wd, "FUNCTION") == 0)
-		{
+	else if (REGMATCH(RE_DROP_obj_1) ||
+			 REGMATCH(RE_DROP_obj_2) ||
+			 REGMATCH(RE_DROP_obj_3))
+	{
+		if (REGMATCH(RE_DROP_FUNCTION_id))
 			COMPLETE_WITH_CONST("(");
-		}
 		else
 		{
 			static const char *const list_DROPCR[] =
@@ -2900,8 +2454,7 @@ psql_completion(const char *text, int start, int end)
 			COMPLETE_WITH_LIST(list_DROPCR);
 		}
 	}
-	else if (pg_strcasecmp(prev2_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOREIGN") == 0)
+	else if (REGMATCH(RE_DROP_FOREIGN))
 	{
 		static const char *const drop_CREATE_FOREIGN[] =
 		{"DATA WRAPPER", "TABLE", NULL};
@@ -2910,34 +2463,19 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* DROP MATERIALIZED VIEW */
-	else if (pg_strcasecmp(prev2_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev_wd, "MATERIALIZED") == 0)
-	{
+	else if (REGMATCH(RE_DROP_MATERIALIZED))
 		COMPLETE_WITH_CONST("VIEW");
-	}
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev_wd, "VIEW") == 0)
-	{
+	else if (REGMATCH(RE_DROP_MATERIALIZED_VIEW))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews, NULL);
-	}
 
-	else if (pg_strcasecmp(prev4_wd, "DROP") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "AGGREGATE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "FUNCTION") == 0) &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
-		COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
+	else if (REGMATCH(RE_DROP_AGGoFUNC_id_))
+		COMPLETE_WITH_FUNCTION_ARG(CAPTURE(1));
 	/* DROP OWNED BY */
-	else if (pg_strcasecmp(prev2_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev_wd, "OWNED") == 0)
+	else if (REGMATCH(RE_DROP_OWNED))
 		COMPLETE_WITH_CONST("BY");
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "OWNED") == 0 &&
-			 pg_strcasecmp(prev_wd, "BY") == 0)
+	else if (REGMATCH(RE_DROP_OWNED_BY))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TEXT") == 0 &&
-			 pg_strcasecmp(prev_wd, "SEARCH") == 0)
+	else if (REGMATCH(RE_DROP_TEXT_SEARARCH))
 	{
 
 		static const char *const list_ALTERTEXTSEARCH[] =
@@ -2947,21 +2485,14 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* DROP TRIGGER */
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "TRIGGER") == 0)
-	{
+	else if (REGMATCH(RE_DROP_TRIGGER_id))
 		COMPLETE_WITH_CONST("ON");
-	}
-	else if (pg_strcasecmp(prev4_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev3_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_DROP_TRIGGER_id_ON))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_trigger);
 	}
-	else if (pg_strcasecmp(prev5_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev4_wd, "TRIGGER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_DROP_TRIGGER_id_ON_id))
 	{
 		static const char *const list_DROPCR[] =
 		{"CASCADE", "RESTRICT", NULL};
@@ -2970,55 +2501,34 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* DROP EVENT TRIGGER */
-	else if (pg_strcasecmp(prev2_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev_wd, "EVENT") == 0)
-	{
+	else if (REGMATCH(RE_DROP_EVENT))
 		COMPLETE_WITH_CONST("TRIGGER");
-	}
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "EVENT") == 0 &&
-			 pg_strcasecmp(prev_wd, "TRIGGER") == 0)
-	{
+	else if (REGMATCH(RE_DROP_EVENT_TRIGGER))
 		COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
-	}
+
 
 	/* DROP POLICY <name>  */
-	else if (pg_strcasecmp(prev2_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev_wd, "POLICY") == 0)
-	{
+	else if (REGMATCH(RE_DROP_POLICY))
 		COMPLETE_WITH_QUERY(Query_for_list_of_policies);
-	}
 	/* DROP POLICY <name> ON */
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "POLICY") == 0)
-	{
+	else if (REGMATCH(RE_DROP_POLICY_id))
 		COMPLETE_WITH_CONST("ON");
-	}
 	/* DROP POLICY <name> ON <table> */
-	else if (pg_strcasecmp(prev4_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev3_wd, "POLICY") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_DROP_POLICY_id_ON))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_policy);
 	}
 
 	/* DROP RULE */
-	else if (pg_strcasecmp(prev3_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev2_wd, "RULE") == 0)
-	{
+	else if (REGMATCH(RE_DROP_RULE_id))
 		COMPLETE_WITH_CONST("ON");
-	}
-	else if (pg_strcasecmp(prev4_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev3_wd, "RULE") == 0 &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_DROP_RULE_id_ON))
 	{
-		completion_info_charp = prev2_wd;
+		completion_info_charp = CAPTURE(1);
 		COMPLETE_WITH_QUERY(Query_for_list_of_tables_for_rule);
 	}
-	else if (pg_strcasecmp(prev5_wd, "DROP") == 0 &&
-			 pg_strcasecmp(prev4_wd, "RULE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_DROP_RULE_id_ON_id))
 	{
 		static const char *const list_DROPCR[] =
 		{"CASCADE", "RESTRICT", NULL};
@@ -3027,8 +2537,7 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* EXECUTE, but not EXECUTE embedded in other commands */
-	else if (pg_strcasecmp(prev_wd, "EXECUTE") == 0 &&
-			 prev2_wd[0] == '\0')
+	else if (REGMATCH(RE_EXECUTE))
 		COMPLETE_WITH_QUERY(Query_for_list_of_prepared_statements);
 
 /* EXPLAIN */
@@ -3036,26 +2545,21 @@ psql_completion(const char *text, int start, int end)
 	/*
 	 * Complete EXPLAIN [ANALYZE] [VERBOSE] with list of EXPLAIN-able commands
 	 */
-	else if (pg_strcasecmp(prev_wd, "EXPLAIN") == 0)
+	else if (REGMATCH(RE_EXPLAIN))
 	{
 		static const char *const list_EXPLAIN[] =
 		{"SELECT", "INSERT", "DELETE", "UPDATE", "DECLARE", "ANALYZE", "VERBOSE", NULL};
 
 		COMPLETE_WITH_LIST(list_EXPLAIN);
 	}
-	else if (pg_strcasecmp(prev2_wd, "EXPLAIN") == 0 &&
-			 pg_strcasecmp(prev_wd, "ANALYZE") == 0)
+	else if (REGMATCH(RE_EXPLAIN_ANALYZE))
 	{
 		static const char *const list_EXPLAIN[] =
 		{"SELECT", "INSERT", "DELETE", "UPDATE", "DECLARE", "VERBOSE", NULL};
 
 		COMPLETE_WITH_LIST(list_EXPLAIN);
 	}
-	else if ((pg_strcasecmp(prev2_wd, "EXPLAIN") == 0 &&
-			  pg_strcasecmp(prev_wd, "VERBOSE") == 0) ||
-			 (pg_strcasecmp(prev3_wd, "EXPLAIN") == 0 &&
-			  pg_strcasecmp(prev2_wd, "ANALYZE") == 0 &&
-			  pg_strcasecmp(prev_wd, "VERBOSE") == 0))
+	else if (REGMATCH(RE_EXPLAIN_oANALYZE_VERBOSE))
 	{
 		static const char *const list_EXPLAIN[] =
 		{"SELECT", "INSERT", "DELETE", "UPDATE", "DECLARE", NULL};
@@ -3065,8 +2569,7 @@ psql_completion(const char *text, int start, int end)
 
 /* FETCH && MOVE */
 	/* Complete FETCH with one of FORWARD, BACKWARD, RELATIVE */
-	else if (pg_strcasecmp(prev_wd, "FETCH") == 0 ||
-			 pg_strcasecmp(prev_wd, "MOVE") == 0)
+	else if (REGMATCH(RE_FETCHoMOVE))
 	{
 		static const char *const list_FETCH1[] =
 		{"ABSOLUTE", "BACKWARD", "FORWARD", "RELATIVE", NULL};
@@ -3074,8 +2577,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_FETCH1);
 	}
 	/* Complete FETCH <sth> with one of ALL, NEXT, PRIOR */
-	else if (pg_strcasecmp(prev2_wd, "FETCH") == 0 ||
-			 pg_strcasecmp(prev2_wd, "MOVE") == 0)
+	else if (REGMATCH(RE_FETCHoMOVE_id))
 	{
 		static const char *const list_FETCH2[] =
 		{"ALL", "NEXT", "PRIOR", NULL};
@@ -3088,8 +2590,7 @@ psql_completion(const char *text, int start, int end)
 	 * but we may as well tab-complete both: perhaps some users prefer one
 	 * variant or the other.
 	 */
-	else if (pg_strcasecmp(prev3_wd, "FETCH") == 0 ||
-			 pg_strcasecmp(prev3_wd, "MOVE") == 0)
+	else if (REGMATCH(RE_FETCHoMOVE_any_any))
 	{
 		static const char *const list_FROMIN[] =
 		{"FROM", "IN", NULL};
@@ -3099,27 +2600,20 @@ psql_completion(const char *text, int start, int end)
 
 /* FOREIGN DATA WRAPPER */
 	/* applies in ALTER/DROP FDW and in CREATE SERVER */
-	else if (pg_strcasecmp(prev4_wd, "CREATE") != 0 &&
-			 pg_strcasecmp(prev3_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DATA") == 0 &&
-			 pg_strcasecmp(prev_wd, "WRAPPER") == 0)
+	else if (REGMATCH(RE_negCREATE_FOREIGN_DATA_WRAPPER))
 		COMPLETE_WITH_QUERY(Query_for_list_of_fdws);
 
 /* FOREIGN TABLE */
-	else if (pg_strcasecmp(prev3_wd, "CREATE") != 0 &&
-			 pg_strcasecmp(prev2_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev_wd, "TABLE") == 0)
+	else if (REGMATCH(RE_negCREATE_FOREIGN_TABLE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables, NULL);
 
 /* FOREIGN SERVER */
-	else if (pg_strcasecmp(prev2_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev_wd, "SERVER") == 0)
+	else if (REGMATCH(RE_FOREIGN_SERVER))
 		COMPLETE_WITH_QUERY(Query_for_list_of_servers);
 
 /* GRANT && REVOKE */
 	/* Complete GRANT/REVOKE with a list of roles and privileges */
-	else if (pg_strcasecmp(prev_wd, "GRANT") == 0 ||
-			 pg_strcasecmp(prev_wd, "REVOKE") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE))
 	{
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles
 							" UNION SELECT 'SELECT'"
@@ -3141,31 +2635,14 @@ psql_completion(const char *text, int start, int end)
 	 * Complete GRANT/REVOKE <privilege> with "ON", GRANT/REVOKE <role> with
 	 * TO/FROM
 	 */
-	else if (pg_strcasecmp(prev2_wd, "GRANT") == 0 ||
-			 pg_strcasecmp(prev2_wd, "REVOKE") == 0)
-	{
-		if (pg_strcasecmp(prev_wd, "SELECT") == 0
-			|| pg_strcasecmp(prev_wd, "INSERT") == 0
-			|| pg_strcasecmp(prev_wd, "UPDATE") == 0
-			|| pg_strcasecmp(prev_wd, "DELETE") == 0
-			|| pg_strcasecmp(prev_wd, "TRUNCATE") == 0
-			|| pg_strcasecmp(prev_wd, "REFERENCES") == 0
-			|| pg_strcasecmp(prev_wd, "TRIGGER") == 0
-			|| pg_strcasecmp(prev_wd, "CREATE") == 0
-			|| pg_strcasecmp(prev_wd, "CONNECT") == 0
-			|| pg_strcasecmp(prev_wd, "TEMPORARY") == 0
-			|| pg_strcasecmp(prev_wd, "TEMP") == 0
-			|| pg_strcasecmp(prev_wd, "EXECUTE") == 0
-			|| pg_strcasecmp(prev_wd, "USAGE") == 0
-			|| pg_strcasecmp(prev_wd, "ALL") == 0)
-			COMPLETE_WITH_CONST("ON");
+	else if (REGMATCH(RE_GRANToREVOKE_kwd))
+		COMPLETE_WITH_CONST("ON");
+	else if (REGMATCH(RE_GRANToREVOKE_id))
+	{
+		if (pg_strcasecmp(CAPTURE(1), "GRANT") == 0)
+			COMPLETE_WITH_CONST("TO");
 		else
-		{
-			if (pg_strcasecmp(prev2_wd, "GRANT") == 0)
-				COMPLETE_WITH_CONST("TO");
-			else
-				COMPLETE_WITH_CONST("FROM");
-		}
+			COMPLETE_WITH_CONST("FROM");
 	}
 
 	/*
@@ -3179,9 +2656,7 @@ psql_completion(const char *text, int start, int end)
 	 * here will only work if the privilege list contains exactly one
 	 * privilege.
 	 */
-	else if ((pg_strcasecmp(prev3_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev3_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev_wd, "ON") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsvmf,
 								   " UNION SELECT 'ALL FUNCTIONS IN SCHEMA'"
 								   " UNION SELECT 'ALL SEQUENCES IN SCHEMA'"
@@ -3199,10 +2674,7 @@ psql_completion(const char *text, int start, int end)
 								   " UNION SELECT 'TABLESPACE'"
 								   " UNION SELECT 'TYPE'");
 
-	else if ((pg_strcasecmp(prev4_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev4_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "ALL") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_ALL))
 	{
 		static const char *const list_privilege_all[] =
 		{"FUNCTIONS IN SCHEMA", "SEQUENCES IN SCHEMA", "TABLES IN SCHEMA",
@@ -3211,10 +2683,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(list_privilege_all);
 	}
 
-	else if ((pg_strcasecmp(prev4_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev4_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOREIGN") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_FOREIGN))
 	{
 		static const char *const list_privilege_foreign[] =
 		{"DATA WRAPPER", "SERVER", NULL};
@@ -3228,70 +2697,56 @@ psql_completion(const char *text, int start, int end)
 	 *
 	 * Complete "GRANT/REVOKE * ON * " with "TO/FROM".
 	 */
-	else if ((pg_strcasecmp(prev4_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev4_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev2_wd, "ON") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_any))
 	{
-		if (pg_strcasecmp(prev_wd, "DATABASE") == 0)
+		bool is_grant = (pg_strcasecmp(CAPTURE(1), "GRANT") == 0);
+		char *any = CAPTURE(2);
+		if (pg_strcasecmp(any, "DATABASE") == 0)
 			COMPLETE_WITH_QUERY(Query_for_list_of_databases);
-		else if (pg_strcasecmp(prev_wd, "DOMAIN") == 0)
+		else if (pg_strcasecmp(any, "DOMAIN") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains, NULL);
-		else if (pg_strcasecmp(prev_wd, "FUNCTION") == 0)
+		else if (pg_strcasecmp(any, "FUNCTION") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_functions, NULL);
-		else if (pg_strcasecmp(prev_wd, "LANGUAGE") == 0)
+		else if (pg_strcasecmp(any, "LANGUAGE") == 0)
 			COMPLETE_WITH_QUERY(Query_for_list_of_languages);
-		else if (pg_strcasecmp(prev_wd, "SCHEMA") == 0)
+		else if (pg_strcasecmp(any, "SCHEMA") == 0)
 			COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
-		else if (pg_strcasecmp(prev_wd, "SEQUENCE") == 0)
+		else if (pg_strcasecmp(any, "SEQUENCE") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences, NULL);
-		else if (pg_strcasecmp(prev_wd, "TABLE") == 0)
+		else if (pg_strcasecmp(any, "TABLE") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsvmf, NULL);
-		else if (pg_strcasecmp(prev_wd, "TABLESPACE") == 0)
+		else if (pg_strcasecmp(any, "TABLESPACE") == 0)
 			COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
-		else if (pg_strcasecmp(prev_wd, "TYPE") == 0)
+		else if (pg_strcasecmp(any, "TYPE") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes, NULL);
-		else if (pg_strcasecmp(prev4_wd, "GRANT") == 0)
+		else if (is_grant)
 			COMPLETE_WITH_CONST("TO");
 		else
 			COMPLETE_WITH_CONST("FROM");
 	}
 
 	/* Complete "GRANT/REVOKE * ON ALL * IN SCHEMA *" with TO/FROM */
-	else if ((pg_strcasecmp(prev8_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev8_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev6_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev5_wd, "ALL") == 0 &&
-			 pg_strcasecmp(prev3_wd, "IN") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SCHEMA") == 0)
-	{
-		if (pg_strcasecmp(prev8_wd, "GRANT") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_ALL_any_IN_SCHEMA_id))
+	{
+		if (pg_strcasecmp(CAPTURE(1), "GRANT") == 0)
 			COMPLETE_WITH_CONST("TO");
 		else
 			COMPLETE_WITH_CONST("FROM");
 	}
 
 	/* Complete "GRANT/REVOKE * ON FOREIGN DATA WRAPPER *" with TO/FROM */
-	else if ((pg_strcasecmp(prev7_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev7_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev5_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev3_wd, "DATA") == 0 &&
-			 pg_strcasecmp(prev2_wd, "WRAPPER") == 0)
-	{
-		if (pg_strcasecmp(prev7_wd, "GRANT") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_FDW_id))
+	{
+		if (pg_strcasecmp(CAPTURE(1), "GRANT") == 0)
 			COMPLETE_WITH_CONST("TO");
 		else
 			COMPLETE_WITH_CONST("FROM");
 	}
 
 	/* Complete "GRANT/REVOKE * ON FOREIGN SERVER *" with TO/FROM */
-	else if ((pg_strcasecmp(prev6_wd, "GRANT") == 0 ||
-			  pg_strcasecmp(prev6_wd, "REVOKE") == 0) &&
-			 pg_strcasecmp(prev4_wd, "ON") == 0 &&
-			 pg_strcasecmp(prev3_wd, "FOREIGN") == 0 &&
-			 pg_strcasecmp(prev2_wd, "SERVER") == 0)
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_FOREIGN_SERVER_id))
 	{
-		if (pg_strcasecmp(prev6_wd, "GRANT") == 0)
+		if (pg_strcasecmp(CAPTURE(1), "GRANT") == 0)
 			COMPLETE_WITH_CONST("TO");
 		else
 			COMPLETE_WITH_CONST("FROM");
@@ -3301,76 +2756,51 @@ psql_completion(const char *text, int start, int end)
 	 * Complete "GRANT/REVOKE ... TO/FROM" with username, PUBLIC,
 	 * CURRENT_USER, or SESSION_USER.
 	 */
-	else if (((pg_strcasecmp(prev9_wd, "GRANT") == 0 ||
-			   pg_strcasecmp(prev8_wd, "GRANT") == 0 ||
-			   pg_strcasecmp(prev7_wd, "GRANT") == 0 ||
-			   pg_strcasecmp(prev6_wd, "GRANT") == 0 ||
-			   pg_strcasecmp(prev5_wd, "GRANT") == 0) &&
-			  pg_strcasecmp(prev_wd, "TO") == 0) ||
-			 ((pg_strcasecmp(prev9_wd, "REVOKE") == 0 ||
-			   pg_strcasecmp(prev8_wd, "REVOKE") == 0 ||
-			   pg_strcasecmp(prev7_wd, "REVOKE") == 0 ||
-			   pg_strcasecmp(prev6_wd, "REVOKE") == 0 ||
-			   pg_strcasecmp(prev5_wd, "REVOKE") == 0) &&
-			  pg_strcasecmp(prev_wd, "FROM") == 0))
+	else if (REGMATCH(RE_GRANToREVOKE_any_TO))
 		COMPLETE_WITH_QUERY(Query_for_list_of_grant_roles);
 
 	/* Complete "GRANT/REVOKE * ON * *" with TO/FROM */
-	else if (pg_strcasecmp(prev5_wd, "GRANT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0)
-		COMPLETE_WITH_CONST("TO");
-
-	else if (pg_strcasecmp(prev5_wd, "REVOKE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0)
-		COMPLETE_WITH_CONST("FROM");
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_ON_kwd_id))
+	{
+		if (pg_strcasecmp(CAPTURE(1), "GRANT") == 0)
+			COMPLETE_WITH_CONST("TO");
+		else
+			COMPLETE_WITH_CONST("FROM");
+	}
 
 	/*
 	 * Complete "GRANT/REVOKE * TO/FROM" with username, PUBLIC,
 	 * CURRENT_USER, or SESSION_USER.
 	 */
-	else if (pg_strcasecmp(prev3_wd, "GRANT") == 0 &&
-			 pg_strcasecmp(prev_wd, "TO") == 0)
-	{
-		COMPLETE_WITH_QUERY(Query_for_list_of_grant_roles);
-	}
-	else if (pg_strcasecmp(prev3_wd, "REVOKE") == 0 &&
-			 pg_strcasecmp(prev_wd, "FROM") == 0)
-	{
+	else if (REGMATCH(RE_GRANToREVOKE_kwd_TO))
 		COMPLETE_WITH_QUERY(Query_for_list_of_grant_roles);
-	}
 
 /* GROUP BY */
-	else if (pg_strcasecmp(prev3_wd, "FROM") == 0 &&
-			 pg_strcasecmp(prev_wd, "GROUP") == 0)
+	else if (REGMATCH(RE_FROM_any_GROUP))
 		COMPLETE_WITH_CONST("BY");
 
 /* IMPORT FOREIGN SCHEMA */
-	else if (pg_strcasecmp(prev_wd, "IMPORT") == 0)
+	else if (REGMATCH(RE_IMPORT))
 		COMPLETE_WITH_CONST("FOREIGN SCHEMA");
-	else if (pg_strcasecmp(prev2_wd, "IMPORT") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOREIGN") == 0)
+	else if (REGMATCH(RE_IMPORT_FOREIGN))
 		COMPLETE_WITH_CONST("SCHEMA");
 
 /* INSERT */
 	/* Complete INSERT with "INTO" */
-	else if (pg_strcasecmp(prev_wd, "INSERT") == 0)
+	else if (REGMATCH(RE_INSERT))
 		COMPLETE_WITH_CONST("INTO");
 	/* Complete INSERT INTO with table names */
-	else if (pg_strcasecmp(prev2_wd, "INSERT") == 0 &&
-			 pg_strcasecmp(prev_wd, "INTO") == 0)
+	else if (REGMATCH(RE_INSERT_INTO))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables, NULL);
 	/* Complete "INSERT INTO <table> (" with attribute names */
-	else if (pg_strcasecmp(prev4_wd, "INSERT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "INTO") == 0 &&
-			 pg_strcasecmp(prev_wd, "(") == 0)
-		COMPLETE_WITH_ATTR(prev2_wd, "");
+	else if (REGMATCH(RE_INSERT_INTO_id_))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 
 	/*
 	 * Complete INSERT INTO <table> with "(" or "VALUES" or "SELECT" or
 	 * "TABLE" or "DEFAULT VALUES"
 	 */
-	else if (pg_strcasecmp(prev3_wd, "INSERT") == 0 &&
-			 pg_strcasecmp(prev2_wd, "INTO") == 0)
+	else if (REGMATCH(RE_INSERT_INTO_id))
 	{
 		static const char *const list_INSERT[] =
 		{"(", "DEFAULT VALUES", "SELECT", "TABLE", "VALUES", NULL};
@@ -3382,9 +2812,7 @@ psql_completion(const char *text, int start, int end)
 	 * Complete INSERT INTO <table> (attribs) with "VALUES" or "SELECT" or
 	 * "TABLE"
 	 */
-	else if (pg_strcasecmp(prev4_wd, "INSERT") == 0 &&
-			 pg_strcasecmp(prev3_wd, "INTO") == 0 &&
-			 prev_wd[strlen(prev_wd) - 1] == ')')
+	else if (REGMATCH(RE_INSERT_INTO_id__))
 	{
 		static const char *const list_INSERT[] =
 		{"SELECT", "TABLE", "VALUES", NULL};
@@ -3393,33 +2821,25 @@ psql_completion(const char *text, int start, int end)
 	}
 
 	/* Insert an open parenthesis after "VALUES" */
-	else if (pg_strcasecmp(prev_wd, "VALUES") == 0 &&
-			 pg_strcasecmp(prev2_wd, "DEFAULT") != 0)
+	else if (REGMATCH(RE_negDEFAULT_VALUES))
 		COMPLETE_WITH_CONST("(");
 
 /* LOCK */
 	/* Complete LOCK [TABLE] with a list of tables */
-	else if (pg_strcasecmp(prev_wd, "LOCK") == 0)
+	else if (REGMATCH(RE_LOCK))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables,
 								   " UNION SELECT 'TABLE'");
-	else if (pg_strcasecmp(prev_wd, "TABLE") == 0 &&
-			 pg_strcasecmp(prev2_wd, "LOCK") == 0)
+	else if (REGMATCH(RE_LOCK_TABLE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, "");
 
 	/* For the following, handle the case of a single table only for now */
 
 	/* Complete LOCK [TABLE] <table> with "IN" */
-	else if ((pg_strcasecmp(prev2_wd, "LOCK") == 0 &&
-			  pg_strcasecmp(prev_wd, "TABLE") != 0) ||
-			 (pg_strcasecmp(prev2_wd, "TABLE") == 0 &&
-			  pg_strcasecmp(prev3_wd, "LOCK") == 0))
+	else if (REGMATCH(RE_LOCK_oTABLE_id))
 		COMPLETE_WITH_CONST("IN");
 
 	/* Complete LOCK [TABLE] <table> IN with a lock mode */
-	else if (pg_strcasecmp(prev_wd, "IN") == 0 &&
-			 (pg_strcasecmp(prev3_wd, "LOCK") == 0 ||
-			  (pg_strcasecmp(prev3_wd, "TABLE") == 0 &&
-			   pg_strcasecmp(prev4_wd, "LOCK") == 0)))
+	else if (REGMATCH(RE_LOCK_oTABLE_id_IN))
 	{
 		static const char *const lock_modes[] =
 		{"ACCESS SHARE MODE",
@@ -3432,30 +2852,25 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* NOTIFY */
-	else if (pg_strcasecmp(prev_wd, "NOTIFY") == 0)
+	else if (REGMATCH(RE_NOTIFY))
 		COMPLETE_WITH_QUERY("SELECT pg_catalog.quote_ident(channel) FROM pg_catalog.pg_listening_channels() AS channel WHERE substring(pg_catalog.quote_ident(channel),1,%d)='%s'");
 
 /* OPTIONS */
-	else if (pg_strcasecmp(prev_wd, "OPTIONS") == 0)
+	else if (REGMATCH(RE_OPTIONS))
 		COMPLETE_WITH_CONST("(");
 
 /* OWNER TO  - complete with available roles */
-	else if (pg_strcasecmp(prev2_wd, "OWNER") == 0 &&
-			 pg_strcasecmp(prev_wd, "TO") == 0)
+	else if (REGMATCH(RE_OWNER_TO))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
 
 /* ORDER BY */
-	else if (pg_strcasecmp(prev3_wd, "FROM") == 0 &&
-			 pg_strcasecmp(prev_wd, "ORDER") == 0)
+	else if (REGMATCH(RE_FROM_any_ORDER))
 		COMPLETE_WITH_CONST("BY");
-	else if (pg_strcasecmp(prev4_wd, "FROM") == 0 &&
-			 pg_strcasecmp(prev2_wd, "ORDER") == 0 &&
-			 pg_strcasecmp(prev_wd, "BY") == 0)
-		COMPLETE_WITH_ATTR(prev3_wd, "");
+	else if (REGMATCH(RE_FROM_any_ORDER_BY))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 
 /* PREPARE xx AS */
-	else if (pg_strcasecmp(prev_wd, "AS") == 0 &&
-			 pg_strcasecmp(prev3_wd, "PREPARE") == 0)
+	else if (REGMATCH(RE_PREPARE_any_AS))
 	{
 		static const char *const list_PREPARE[] =
 		{"SELECT", "UPDATE", "INSERT", "DELETE", NULL};
@@ -3469,116 +2884,78 @@ psql_completion(const char *text, int start, int end)
  */
 
 /* REASSIGN OWNED BY xxx TO yyy */
-	else if (pg_strcasecmp(prev_wd, "REASSIGN") == 0)
+	else if (REGMATCH(RE_REASSIGN))
 		COMPLETE_WITH_CONST("OWNED");
-	else if (pg_strcasecmp(prev_wd, "OWNED") == 0 &&
-			 pg_strcasecmp(prev2_wd, "REASSIGN") == 0)
+	else if (REGMATCH(RE_REASSIGN_OWNED))
 		COMPLETE_WITH_CONST("BY");
-	else if (pg_strcasecmp(prev_wd, "BY") == 0 &&
-			 pg_strcasecmp(prev2_wd, "OWNED") == 0 &&
-			 pg_strcasecmp(prev3_wd, "REASSIGN") == 0)
+	else if (REGMATCH(RE_REASSIGN_OWNED_BY))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
-	else if (pg_strcasecmp(prev2_wd, "BY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "OWNED") == 0 &&
-			 pg_strcasecmp(prev4_wd, "REASSIGN") == 0)
+	else if (REGMATCH(RE_REASSIGN_OWNED_BY_id))
 		COMPLETE_WITH_CONST("TO");
-	else if (pg_strcasecmp(prev_wd, "TO") == 0 &&
-			 pg_strcasecmp(prev3_wd, "BY") == 0 &&
-			 pg_strcasecmp(prev4_wd, "OWNED") == 0 &&
-			 pg_strcasecmp(prev5_wd, "REASSIGN") == 0)
+	else if (REGMATCH(RE_REASSIGN_OWNED_BY_id_TO))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
 
 /* REFRESH MATERIALIZED VIEW */
-	else if (pg_strcasecmp(prev_wd, "REFRESH") == 0)
+	else if (REGMATCH(RE_REFRESH))
 		COMPLETE_WITH_CONST("MATERIALIZED VIEW");
-	else if (pg_strcasecmp(prev2_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev_wd, "MATERIALIZED") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED))
 		COMPLETE_WITH_CONST("VIEW");
-	else if (pg_strcasecmp(prev3_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev2_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev_wd, "VIEW") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews,
 								   " UNION SELECT 'CONCURRENTLY'");
-	else if (pg_strcasecmp(prev4_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev3_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev_wd, "CONCURRENTLY") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW_CONC))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews, NULL);
-	else if (pg_strcasecmp(prev4_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev3_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev2_wd, "VIEW") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW_id))
 		COMPLETE_WITH_CONST("WITH");
-	else if (pg_strcasecmp(prev5_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev4_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev3_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONCURRENTLY") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW_CONC_id))
 		COMPLETE_WITH_CONST("WITH DATA");
-	else if (pg_strcasecmp(prev5_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev4_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev3_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev_wd, "WITH") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW_id_WITH))
 	{
 		static const char *const list_WITH_DATA[] =
 		{"NO DATA", "DATA", NULL};
 
 		COMPLETE_WITH_LIST(list_WITH_DATA);
 	}
-	else if (pg_strcasecmp(prev6_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev5_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev4_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev3_wd, "CONCURRENTLY") == 0 &&
-			 pg_strcasecmp(prev_wd, "WITH") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW_CONC_id_WITH))
 		COMPLETE_WITH_CONST("DATA");
-	else if (pg_strcasecmp(prev6_wd, "REFRESH") == 0 &&
-			 pg_strcasecmp(prev5_wd, "MATERIALIZED") == 0 &&
-			 pg_strcasecmp(prev4_wd, "VIEW") == 0 &&
-			 pg_strcasecmp(prev2_wd, "WITH") == 0 &&
-			 pg_strcasecmp(prev_wd, "NO") == 0)
+	else if (REGMATCH(RE_REFRESH_MATERIALIZED_VIEW_id_WITH_NO))
 		COMPLETE_WITH_CONST("DATA");
 
 /* REINDEX */
-	else if (pg_strcasecmp(prev_wd, "REINDEX") == 0)
+	else if (REGMATCH(RE_REINDEX))
 	{
 		static const char *const list_REINDEX[] =
 		{"TABLE", "INDEX", "SYSTEM", "SCHEMA", "DATABASE", NULL};
 
 		COMPLETE_WITH_LIST(list_REINDEX);
 	}
-	else if (pg_strcasecmp(prev2_wd, "REINDEX") == 0)
+	else if (REGMATCH(RE_REINDEX_kwd))
 	{
-		if (pg_strcasecmp(prev_wd, "TABLE") == 0)
+		char *kwd = CAPTURE(1);
+		if (pg_strcasecmp(kwd, "TABLE") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm, NULL);
-		else if (pg_strcasecmp(prev_wd, "INDEX") == 0)
+		else if (pg_strcasecmp(kwd, "INDEX") == 0)
 			COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes, NULL);
-		else if (pg_strcasecmp(prev_wd, "SCHEMA") == 0)
+		else if (pg_strcasecmp(kwd, "SCHEMA") == 0)
 			COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
-		else if (pg_strcasecmp(prev_wd, "SYSTEM") == 0 ||
-				 pg_strcasecmp(prev_wd, "DATABASE") == 0)
+		else if (pg_strcasecmp(kwd, "SYSTEM") == 0 ||
+				 pg_strcasecmp(kwd, "DATABASE") == 0)
 			COMPLETE_WITH_QUERY(Query_for_list_of_databases);
 	}
 
 /* SECURITY LABEL */
-	else if (pg_strcasecmp(prev_wd, "SECURITY") == 0)
+	else if (REGMATCH(RE_SECURITY))
 		COMPLETE_WITH_CONST("LABEL");
-	else if (pg_strcasecmp(prev2_wd, "SECURITY") == 0 &&
-			 pg_strcasecmp(prev_wd, "LABEL") == 0)
+	else if (REGMATCH(RE_SECURITY_LABEL))
 	{
 		static const char *const list_SECURITY_LABEL_preposition[] =
-		{"ON", "FOR"};
+		{"ON", "FOR", NULL};
 
 		COMPLETE_WITH_LIST(list_SECURITY_LABEL_preposition);
 	}
-	else if (pg_strcasecmp(prev4_wd, "SECURITY") == 0 &&
-			 pg_strcasecmp(prev3_wd, "LABEL") == 0 &&
-			 pg_strcasecmp(prev2_wd, "FOR") == 0)
+	else if (REGMATCH(RE_SECURITY_LABEL_FOR_id))
 		COMPLETE_WITH_CONST("ON");
-	else if ((pg_strcasecmp(prev3_wd, "SECURITY") == 0 &&
-			  pg_strcasecmp(prev2_wd, "LABEL") == 0 &&
-			  pg_strcasecmp(prev_wd, "ON") == 0) ||
-			 (pg_strcasecmp(prev5_wd, "SECURITY") == 0 &&
-			  pg_strcasecmp(prev4_wd, "LABEL") == 0 &&
-			  pg_strcasecmp(prev3_wd, "FOR") == 0 &&
-			  pg_strcasecmp(prev_wd, "ON") == 0))
+	else if (REGMATCH(RE_SECURITY_LABEL_oFORname_ON))
 	{
 		static const char *const list_SECURITY_LABEL[] =
 		{"LANGUAGE", "SCHEMA", "SEQUENCE", "TABLE", "TYPE", "VIEW",
@@ -3587,9 +2964,7 @@ psql_completion(const char *text, int start, int end)
 
 		COMPLETE_WITH_LIST(list_SECURITY_LABEL);
 	}
-	else if (pg_strcasecmp(prev5_wd, "SECURITY") == 0 &&
-			 pg_strcasecmp(prev4_wd, "LABEL") == 0 &&
-			 pg_strcasecmp(prev3_wd, "ON") == 0)
+	else if (REGMATCH(RE_SECURITY_LABEL_ON_kwd_id))
 		COMPLETE_WITH_CONST("IS");
 
 /* SELECT */
@@ -3597,78 +2972,37 @@ psql_completion(const char *text, int start, int end)
 
 /* SET, RESET, SHOW */
 	/* Complete with a variable name */
-	else if ((pg_strcasecmp(prev_wd, "SET") == 0 &&
-			  pg_strcasecmp(prev3_wd, "UPDATE") != 0) ||
-			 pg_strcasecmp(prev_wd, "RESET") == 0)
+	else if (REGMATCH(RE_SEToRESET))
 		COMPLETE_WITH_QUERY(Query_for_list_of_set_vars);
-	else if (pg_strcasecmp(prev_wd, "SHOW") == 0)
+	else if (REGMATCH(RE_SHOW))
 		COMPLETE_WITH_QUERY(Query_for_list_of_show_vars);
 	/* Complete "SET TRANSACTION" */
-	else if ((pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			  pg_strcasecmp(prev_wd, "TRANSACTION") == 0)
-			 || (pg_strcasecmp(prev2_wd, "START") == 0
-				 && pg_strcasecmp(prev_wd, "TRANSACTION") == 0)
-			 || (pg_strcasecmp(prev2_wd, "BEGIN") == 0
-				 && pg_strcasecmp(prev_wd, "WORK") == 0)
-			 || (pg_strcasecmp(prev2_wd, "BEGIN") == 0
-				 && pg_strcasecmp(prev_wd, "TRANSACTION") == 0)
-			 || (pg_strcasecmp(prev4_wd, "SESSION") == 0
-				 && pg_strcasecmp(prev3_wd, "CHARACTERISTICS") == 0
-				 && pg_strcasecmp(prev2_wd, "AS") == 0
-				 && pg_strcasecmp(prev_wd, "TRANSACTION") == 0))
+	else if (REGMATCH(RE_SET_TRANSACTIONs))
 	{
 		static const char *const my_list[] =
 		{"ISOLATION LEVEL", "READ", NULL};
 
 		COMPLETE_WITH_LIST(my_list);
 	}
-	else if ((pg_strcasecmp(prev3_wd, "SET") == 0
-			  || pg_strcasecmp(prev3_wd, "BEGIN") == 0
-			  || pg_strcasecmp(prev3_wd, "START") == 0
-			  || (pg_strcasecmp(prev4_wd, "CHARACTERISTICS") == 0
-				  && pg_strcasecmp(prev3_wd, "AS") == 0))
-			 && (pg_strcasecmp(prev2_wd, "TRANSACTION") == 0
-				 || pg_strcasecmp(prev2_wd, "WORK") == 0)
-			 && pg_strcasecmp(prev_wd, "ISOLATION") == 0)
+	else if (REGMATCH(RE_SET_TRANSACTIONs_ISOLATION))
 		COMPLETE_WITH_CONST("LEVEL");
-	else if ((pg_strcasecmp(prev4_wd, "SET") == 0
-			  || pg_strcasecmp(prev4_wd, "BEGIN") == 0
-			  || pg_strcasecmp(prev4_wd, "START") == 0
-			  || pg_strcasecmp(prev4_wd, "AS") == 0)
-			 && (pg_strcasecmp(prev3_wd, "TRANSACTION") == 0
-				 || pg_strcasecmp(prev3_wd, "WORK") == 0)
-			 && pg_strcasecmp(prev2_wd, "ISOLATION") == 0
-			 && pg_strcasecmp(prev_wd, "LEVEL") == 0)
+	else if (REGMATCH(RE_SET_TRANSACTIONs_ISOLATION_LEVEL))
 	{
 		static const char *const my_list[] =
 		{"READ", "REPEATABLE", "SERIALIZABLE", NULL};
 
 		COMPLETE_WITH_LIST(my_list);
 	}
-	else if ((pg_strcasecmp(prev4_wd, "TRANSACTION") == 0 ||
-			  pg_strcasecmp(prev4_wd, "WORK") == 0) &&
-			 pg_strcasecmp(prev3_wd, "ISOLATION") == 0 &&
-			 pg_strcasecmp(prev2_wd, "LEVEL") == 0 &&
-			 pg_strcasecmp(prev_wd, "READ") == 0)
+	else if (REGMATCH(RE_SET_TRANSACTIONs_ISOLATION_LEVEL_READ))
 	{
 		static const char *const my_list[] =
 		{"UNCOMMITTED", "COMMITTED", NULL};
 
 		COMPLETE_WITH_LIST(my_list);
 	}
-	else if ((pg_strcasecmp(prev4_wd, "TRANSACTION") == 0 ||
-			  pg_strcasecmp(prev4_wd, "WORK") == 0) &&
-			 pg_strcasecmp(prev3_wd, "ISOLATION") == 0 &&
-			 pg_strcasecmp(prev2_wd, "LEVEL") == 0 &&
-			 pg_strcasecmp(prev_wd, "REPEATABLE") == 0)
+	else if (REGMATCH(RE_SET_TRANSACTIONs_ISOLATION_LEVEL_REPEATABLE))
 		COMPLETE_WITH_CONST("READ");
-	else if ((pg_strcasecmp(prev3_wd, "SET") == 0 ||
-			  pg_strcasecmp(prev3_wd, "BEGIN") == 0 ||
-			  pg_strcasecmp(prev3_wd, "START") == 0 ||
-			  pg_strcasecmp(prev3_wd, "AS") == 0) &&
-			 (pg_strcasecmp(prev2_wd, "TRANSACTION") == 0 ||
-			  pg_strcasecmp(prev2_wd, "WORK") == 0) &&
-			 pg_strcasecmp(prev_wd, "READ") == 0)
+	else if (REGMATCH(RE_SET_TRANSACTIONs_READ))
 	{
 		static const char *const my_list[] =
 		{"ONLY", "WRITE", NULL};
@@ -3676,14 +3010,12 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(my_list);
 	}
 	/* SET CONSTRAINTS */
-	else if (pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "CONSTRAINTS") == 0)
+	else if (REGMATCH(RE_SET_CONSTRAINTS))
 	{
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_constraints_with_schema, "UNION SELECT 'ALL'");
 	}
 	/* Complete SET CONSTRAINTS <foo> with DEFERRED|IMMEDIATE */
-	else if (pg_strcasecmp(prev3_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev2_wd, "CONSTRAINTS") == 0)
+	else if (REGMATCH(RE_SET_CONSTRAINTS_id))
 	{
 		static const char *const constraint_list[] =
 		{"DEFERRED", "IMMEDIATE", NULL};
@@ -3691,12 +3023,10 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(constraint_list);
 	}
 	/* Complete SET ROLE */
-	else if (pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "ROLE") == 0)
+	else if (REGMATCH(RE_SET_ROLE))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
 	/* Complete SET SESSION with AUTHORIZATION or CHARACTERISTICS... */
-	else if (pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev_wd, "SESSION") == 0)
+	else if (REGMATCH(RE_SET_SESSION))
 	{
 		static const char *const my_list[] =
 		{"AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION", NULL};
@@ -3704,29 +3034,20 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_LIST(my_list);
 	}
 	/* Complete SET SESSION AUTHORIZATION with username */
-	else if (pg_strcasecmp(prev3_wd, "SET") == 0
-			 && pg_strcasecmp(prev2_wd, "SESSION") == 0
-			 && pg_strcasecmp(prev_wd, "AUTHORIZATION") == 0)
+	else if (REGMATCH(RE_SET_SESSION_AUTH))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles " UNION SELECT 'DEFAULT'");
 	/* Complete RESET SESSION with AUTHORIZATION */
-	else if (pg_strcasecmp(prev2_wd, "RESET") == 0 &&
-			 pg_strcasecmp(prev_wd, "SESSION") == 0)
+	else if (REGMATCH(RE_RESET_SESSION))
 		COMPLETE_WITH_CONST("AUTHORIZATION");
 	/* Complete SET <var> with "TO" */
-	else if (pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev4_wd, "UPDATE") != 0 &&
-			 pg_strcasecmp(prev_wd, "TABLESPACE") != 0 &&
-			 pg_strcasecmp(prev_wd, "SCHEMA") != 0 &&
-			 prev_wd[strlen(prev_wd) - 1] != ')' &&
-			 prev_wd[strlen(prev_wd) - 1] != '=' &&
-			 pg_strcasecmp(prev4_wd, "DOMAIN") != 0)
+	else if (REGMATCH(RE_SET_var))
 		COMPLETE_WITH_CONST("TO");
 	/* Suggest possible variable values */
-	else if (pg_strcasecmp(prev3_wd, "SET") == 0 &&
-			 (pg_strcasecmp(prev_wd, "TO") == 0 || strcmp(prev_wd, "=") == 0))
+	else if (REGMATCH(RE_SET_var_TOoEQ))
 	{
+		char *varname = CAPTURE(1);
 		/* special cased code for individual GUCs */
-		if (pg_strcasecmp(prev2_wd, "DateStyle") == 0)
+		if (pg_strcasecmp(varname, "DateStyle") == 0)
 		{
 			static const char *const my_list[] =
 			{"ISO", "SQL", "Postgres", "German",
@@ -3736,7 +3057,7 @@ psql_completion(const char *text, int start, int end)
 
 			COMPLETE_WITH_LIST(my_list);
 		}
-		else if (pg_strcasecmp(prev2_wd, "search_path") == 0)
+		else if (pg_strcasecmp(varname, "search_path") == 0)
 		{
 			COMPLETE_WITH_QUERY(Query_for_list_of_schemas
 								" AND nspname not like 'pg\\_toast%%' "
@@ -3747,13 +3068,13 @@ psql_completion(const char *text, int start, int end)
 		{
 			/* generic, type based, GUC support */
 
-			char	   *guctype = get_guctype(prev2_wd);
+			char	   *guctype = get_guctype(varname);
 
 			if (guctype && strcmp(guctype, "enum") == 0)
 			{
 				char		querybuf[1024];
 
-				snprintf(querybuf, 1024, Query_for_enum, prev2_wd);
+				snprintf(querybuf, 1024, Query_for_enum, varname);
 				COMPLETE_WITH_QUERY(querybuf);
 			}
 			else if (guctype && strcmp(guctype, "bool") == 0)
@@ -3777,35 +3098,34 @@ psql_completion(const char *text, int start, int end)
 	}
 
 /* START TRANSACTION */
-	else if (pg_strcasecmp(prev_wd, "START") == 0)
+	else if (REGMATCH(RE_START))
 		COMPLETE_WITH_CONST("TRANSACTION");
 
 /* TABLE, but not TABLE embedded in other commands */
-	else if (pg_strcasecmp(prev_wd, "TABLE") == 0 &&
-			 prev2_wd[0] == '\0')
+	else if (REGMATCH(RE_TABLE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_relations, NULL);
 
 /* TABLESAMPLE */
-	else if (pg_strcasecmp(prev_wd, "TABLESAMPLE") == 0)
+	else if (REGMATCH(RE_any_TABLESAMPLE))
 		COMPLETE_WITH_QUERY(Query_for_list_of_tablesample_methods);
 
-	else if (pg_strcasecmp(prev2_wd, "TABLESAMPLE") == 0)
+	else if (REGMATCH(RE_any_TABLESAMPLE_id))
 		COMPLETE_WITH_CONST("(");
 
 /* TRUNCATE */
-	else if (pg_strcasecmp(prev_wd, "TRUNCATE") == 0)
+	else if (REGMATCH(RE_TRUNCATE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
 
 /* UNLISTEN */
-	else if (pg_strcasecmp(prev_wd, "UNLISTEN") == 0)
+	else if (REGMATCH(RE_UNLISTEN))
 		COMPLETE_WITH_QUERY("SELECT pg_catalog.quote_ident(channel) FROM pg_catalog.pg_listening_channels() AS channel WHERE substring(pg_catalog.quote_ident(channel),1,%d)='%s' UNION SELECT '*'");
 
 /* UPDATE */
 	/* If prev. word is UPDATE suggest a list of tables */
-	else if (pg_strcasecmp(prev_wd, "UPDATE") == 0)
+	else if (REGMATCH(RE_any_UPDATE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables, NULL);
 	/* Complete UPDATE <table> with "SET" */
-	else if (pg_strcasecmp(prev2_wd, "UPDATE") == 0)
+	else if (REGMATCH(RE_any_UPDATE_id))
 		COMPLETE_WITH_CONST("SET");
 
 	/*
@@ -3813,83 +3133,53 @@ psql_completion(const char *text, int start, int end)
 	 * word) the word before it was (hopefully) a table name and we'll now
 	 * make a list of attributes.
 	 */
-	else if (pg_strcasecmp(prev_wd, "SET") == 0)
-		COMPLETE_WITH_ATTR(prev2_wd, "");
+	else if (REGMATCH(RE_any_id_SET))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 
 /* UPDATE xx SET yy = */
-	else if (pg_strcasecmp(prev2_wd, "SET") == 0 &&
-			 pg_strcasecmp(prev4_wd, "UPDATE") == 0)
+	else if (REGMATCH(RE_any_UPDATE_id_SET_id))
 		COMPLETE_WITH_CONST("=");
 
 /* USER MAPPING */
-	else if ((pg_strcasecmp(prev3_wd, "ALTER") == 0 ||
-			  pg_strcasecmp(prev3_wd, "CREATE") == 0 ||
-			  pg_strcasecmp(prev3_wd, "DROP") == 0) &&
-			 pg_strcasecmp(prev2_wd, "USER") == 0 &&
-			 pg_strcasecmp(prev_wd, "MAPPING") == 0)
+	else if (REGMATCH(RE_CRToALToDRP_USER_MAPPING))
 		COMPLETE_WITH_CONST("FOR");
-	else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
-			 pg_strcasecmp(prev3_wd, "USER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "MAPPING") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOR") == 0)
+	else if (REGMATCH(RE_CREATE_USER_MAPPING_FOR))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles
 							" UNION SELECT 'CURRENT_USER'"
 							" UNION SELECT 'PUBLIC'"
 							" UNION SELECT 'USER'");
-	else if ((pg_strcasecmp(prev4_wd, "ALTER") == 0 ||
-			  pg_strcasecmp(prev4_wd, "DROP") == 0) &&
-			 pg_strcasecmp(prev3_wd, "USER") == 0 &&
-			 pg_strcasecmp(prev2_wd, "MAPPING") == 0 &&
-			 pg_strcasecmp(prev_wd, "FOR") == 0)
+	else if (REGMATCH(RE_ALToDRP_USER_MAPPING_FOR))
 		COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings);
-	else if ((pg_strcasecmp(prev5_wd, "CREATE") == 0 ||
-			  pg_strcasecmp(prev5_wd, "ALTER") == 0 ||
-			  pg_strcasecmp(prev5_wd, "DROP") == 0) &&
-			 pg_strcasecmp(prev4_wd, "USER") == 0 &&
-			 pg_strcasecmp(prev3_wd, "MAPPING") == 0 &&
-			 pg_strcasecmp(prev2_wd, "FOR") == 0)
+	else if (REGMATCH(RE_CRToALToDRP_USER_MAPPING_FOR_id))
 		COMPLETE_WITH_CONST("SERVER");
 
 /*
  * VACUUM [ FULL | FREEZE ] [ VERBOSE ] [ table ]
  * VACUUM [ FULL | FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]
  */
-	else if (pg_strcasecmp(prev_wd, "VACUUM") == 0)
+	else if (REGMATCH(RE_VACUUM))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm,
 								   " UNION SELECT 'FULL'"
 								   " UNION SELECT 'FREEZE'"
 								   " UNION SELECT 'ANALYZE'"
 								   " UNION SELECT 'VERBOSE'");
-	else if (pg_strcasecmp(prev2_wd, "VACUUM") == 0 &&
-			 (pg_strcasecmp(prev_wd, "FULL") == 0 ||
-			  pg_strcasecmp(prev_wd, "FREEZE") == 0))
+	else if (REGMATCH(RE_VACUUM_FULLoFREEZE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm,
 								   " UNION SELECT 'ANALYZE'"
 								   " UNION SELECT 'VERBOSE'");
-	else if (pg_strcasecmp(prev3_wd, "VACUUM") == 0 &&
-			 pg_strcasecmp(prev_wd, "ANALYZE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "FULL") == 0 ||
-			  pg_strcasecmp(prev2_wd, "FREEZE") == 0))
+	else if (REGMATCH(RE_VACUUM_FULLoFREEZE_ANALYZE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm,
 								   " UNION SELECT 'VERBOSE'");
-	else if (pg_strcasecmp(prev3_wd, "VACUUM") == 0 &&
-			 pg_strcasecmp(prev_wd, "VERBOSE") == 0 &&
-			 (pg_strcasecmp(prev2_wd, "FULL") == 0 ||
-			  pg_strcasecmp(prev2_wd, "FREEZE") == 0))
+	else if (REGMATCH(RE_VACUUM_FULLoFREEZE_VERBOSE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm,
 								   " UNION SELECT 'ANALYZE'");
-	else if (pg_strcasecmp(prev2_wd, "VACUUM") == 0 &&
-			 pg_strcasecmp(prev_wd, "VERBOSE") == 0)
+	else if (REGMATCH(RE_VACUUM_VERBOSE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm,
 								   " UNION SELECT 'ANALYZE'");
-	else if (pg_strcasecmp(prev2_wd, "VACUUM") == 0 &&
-			 pg_strcasecmp(prev_wd, "ANALYZE") == 0)
+	else if (REGMATCH(RE_VACUUM_ANALYZE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm,
 								   " UNION SELECT 'VERBOSE'");
-	else if ((pg_strcasecmp(prev_wd, "ANALYZE") == 0 &&
-			  pg_strcasecmp(prev2_wd, "VERBOSE") == 0) ||
-			 (pg_strcasecmp(prev_wd, "VERBOSE") == 0 &&
-			  pg_strcasecmp(prev2_wd, "ANALYZE") == 0))
+	else if (REGMATCH(RE_any_ANLVRBoVRBANL))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tm, NULL);
 
 /* WITH [RECURSIVE] */
@@ -3898,120 +3188,116 @@ psql_completion(const char *text, int start, int end)
 	 * Only match when WITH is the first word, as WITH may appear in many
 	 * other contexts.
 	 */
-	else if (pg_strcasecmp(prev_wd, "WITH") == 0 &&
-			 prev2_wd[0] == '\0')
+	else if (REGMATCH(RE_WITH))
 		COMPLETE_WITH_CONST("RECURSIVE");
 
 /* ANALYZE */
 	/* If the previous word is ANALYZE, produce list of tables */
-	else if (pg_strcasecmp(prev_wd, "ANALYZE") == 0)
+	else if (REGMATCH(RE_any_ANALYZE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tmf, NULL);
 
 /* WHERE */
 	/* Simple case of the word before the where being the table name */
-	else if (pg_strcasecmp(prev_wd, "WHERE") == 0)
-		COMPLETE_WITH_ATTR(prev2_wd, "");
+	else if (REGMATCH(RE_any_id_WHERE))
+		COMPLETE_WITH_ATTR(CAPTURE(1), "");
 
 /* ... FROM ... */
 /* TODO: also include SRF ? */
-	else if (pg_strcasecmp(prev_wd, "FROM") == 0 &&
-			 pg_strcasecmp(prev3_wd, "COPY") != 0 &&
-			 pg_strcasecmp(prev3_wd, "\\copy") != 0)
+	else if (REGMATCH(RE_COPY_id_FROM))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsvmf, NULL);
 
 /* ... JOIN ... */
-	else if (pg_strcasecmp(prev_wd, "JOIN") == 0)
+	else if (REGMATCH(RE_any_JOIN))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsvmf, NULL);
 
 /* Backslash commands */
 /* TODO:  \dc \dd \dl */
-	else if (strcmp(prev_wd, "\\?") == 0)
+	else if (REGMATCH(RE_meta_question)) /* \? */
 	{
 		static const char *const my_list[] =
 		{"commands", "options", "variables", NULL};
 
 		COMPLETE_WITH_LIST_CS(my_list);
 	}
-	else if (strcmp(prev_wd, "\\connect") == 0 || strcmp(prev_wd, "\\c") == 0)
+	else if (REGMATCH(RE_meta_CONNECT)) /* \connect */
 	{
 		if (!recognized_connection_string(text))
 			COMPLETE_WITH_QUERY(Query_for_list_of_databases);
 	}
-	else if (strcmp(prev2_wd, "\\connect") == 0 || strcmp(prev2_wd, "\\c") == 0)
+	else if (REGMATCH(RE_meta_CONNECT_word)) /* \connect []*/
 	{
-		if (!recognized_connection_string(prev_wd))
+		if (!recognized_connection_string(CAPTURE(1)))
 			COMPLETE_WITH_QUERY(Query_for_list_of_roles);
 	}
-	else if (strncmp(prev_wd, "\\da", strlen("\\da")) == 0)
+	else if (REGMATCH(RE_meta_da))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_aggregates, NULL);
-	else if (strncmp(prev_wd, "\\db", strlen("\\db")) == 0)
+	else if (REGMATCH(RE_meta_db))
 		COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
-	else if (strncmp(prev_wd, "\\dD", strlen("\\dD")) == 0)
+	else if (REGMATCH(RE_meta_dD))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains, NULL);
-	else if (strncmp(prev_wd, "\\des", strlen("\\des")) == 0)
+	else if (REGMATCH(RE_meta_des))
 		COMPLETE_WITH_QUERY(Query_for_list_of_servers);
-	else if (strncmp(prev_wd, "\\deu", strlen("\\deu")) == 0)
+	else if (REGMATCH(RE_meta_deu))
 		COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings);
-	else if (strncmp(prev_wd, "\\dew", strlen("\\dew")) == 0)
+	else if (REGMATCH(RE_meta_dew))
 		COMPLETE_WITH_QUERY(Query_for_list_of_fdws);
 
-	else if (strncmp(prev_wd, "\\df", strlen("\\df")) == 0)
+	else if (REGMATCH(RE_meta_df))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_functions, NULL);
-	else if (strncmp(prev_wd, "\\dFd", strlen("\\dFd")) == 0)
+	else if (REGMATCH(RE_meta_dFd))
 		COMPLETE_WITH_QUERY(Query_for_list_of_ts_dictionaries);
-	else if (strncmp(prev_wd, "\\dFp", strlen("\\dFp")) == 0)
+	else if (REGMATCH(RE_meta_dFp))
 		COMPLETE_WITH_QUERY(Query_for_list_of_ts_parsers);
-	else if (strncmp(prev_wd, "\\dFt", strlen("\\dFt")) == 0)
+	else if (REGMATCH(RE_meta_dFt))
 		COMPLETE_WITH_QUERY(Query_for_list_of_ts_templates);
 	/* must be at end of \dF */
-	else if (strncmp(prev_wd, "\\dF", strlen("\\dF")) == 0)
+	else if (REGMATCH(RE_meta_dF))
 		COMPLETE_WITH_QUERY(Query_for_list_of_ts_configurations);
 
-	else if (strncmp(prev_wd, "\\di", strlen("\\di")) == 0)
+	else if (REGMATCH(RE_meta_di))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes, NULL);
-	else if (strncmp(prev_wd, "\\dL", strlen("\\dL")) == 0)
+	else if (REGMATCH(RE_meta_dL))
 		COMPLETE_WITH_QUERY(Query_for_list_of_languages);
-	else if (strncmp(prev_wd, "\\dn", strlen("\\dn")) == 0)
+	else if (REGMATCH(RE_meta_dn))
 		COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
-	else if (strncmp(prev_wd, "\\dp", strlen("\\dp")) == 0
-			 || strncmp(prev_wd, "\\z", strlen("\\z")) == 0)
+	else if (REGMATCH(RE_meta_dpOz))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsvmf, NULL);
-	else if (strncmp(prev_wd, "\\ds", strlen("\\ds")) == 0)
+	else if (REGMATCH(RE_meta_ds))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences, NULL);
-	else if (strncmp(prev_wd, "\\dt", strlen("\\dt")) == 0)
+	else if (REGMATCH(RE_meta_dt))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
-	else if (strncmp(prev_wd, "\\dT", strlen("\\dT")) == 0)
+	else if (REGMATCH(RE_meta_dT))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes, NULL);
-	else if (strncmp(prev_wd, "\\du", strlen("\\du")) == 0
-			 || (strncmp(prev_wd, "\\dg", strlen("\\dg")) == 0))
+	else if (REGMATCH(RE_meta_duOdg))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
-	else if (strncmp(prev_wd, "\\dv", strlen("\\dv")) == 0)
+	else if (REGMATCH(RE_meta_dv))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views, NULL);
-	else if (strncmp(prev_wd, "\\dx", strlen("\\dx")) == 0)
+	else if (REGMATCH(RE_meta_dx))
 		COMPLETE_WITH_QUERY(Query_for_list_of_extensions);
-	else if (strncmp(prev_wd, "\\dm", strlen("\\dm")) == 0)
+	else if (REGMATCH(RE_meta_dm))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews, NULL);
-	else if (strncmp(prev_wd, "\\dE", strlen("\\dE")) == 0)
+	else if (REGMATCH(RE_meta_dE))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables, NULL);
-	else if (strncmp(prev_wd, "\\dy", strlen("\\dy")) == 0)
+	else if (REGMATCH(RE_meta_dy))
 		COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
 
 	/* must be at end of \d list */
-	else if (strncmp(prev_wd, "\\d", strlen("\\d")) == 0)
+	else if (REGMATCH(RE_meta_d))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_relations, NULL);
 
-	else if (strcmp(prev_wd, "\\ef") == 0)
+	else if (REGMATCH(RE_meta_ef))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_functions, NULL);
-	else if (strcmp(prev_wd, "\\ev") == 0)
+	else if (REGMATCH(RE_meta_ev))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views, NULL);
 
-	else if (strcmp(prev_wd, "\\encoding") == 0)
+	else if (REGMATCH(RE_meta_encoding))
 		COMPLETE_WITH_QUERY(Query_for_list_of_encodings);
-	else if (strcmp(prev_wd, "\\h") == 0 || strcmp(prev_wd, "\\help") == 0)
+	else if (REGMATCH(RE_meta_h))
 		COMPLETE_WITH_LIST(sql_commands);
-	else if (strcmp(prev_wd, "\\password") == 0)
+	else if (REGMATCH(RE_meta_password))
 		COMPLETE_WITH_QUERY(Query_for_list_of_roles);
-	else if (strcmp(prev_wd, "\\pset") == 0)
+	else if (REGMATCH(RE_meta_pset))
+
 	{
 		static const char *const my_list[] =
 		{"border", "columns", "expanded", "fieldsep", "fieldsep_zero",
@@ -4022,9 +3308,10 @@ psql_completion(const char *text, int start, int end)
 
 		COMPLETE_WITH_LIST_CS(my_list);
 	}
-	else if (strcmp(prev2_wd, "\\pset") == 0)
+	else if (REGMATCH(RE_meta_pset_id))
 	{
-		if (strcmp(prev_wd, "format") == 0)
+		char *var = CAPTURE(1);
+		if (strcmp(var, "format") == 0)
 		{
 			static const char *const my_list[] =
 			{"unaligned", "aligned", "wrapped", "html", "asciidoc",
@@ -4032,16 +3319,16 @@ psql_completion(const char *text, int start, int end)
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "linestyle") == 0)
+		else if (strcmp(var, "linestyle") == 0)
 		{
 			static const char *const my_list[] =
 			{"ascii", "old-ascii", "unicode", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "unicode_border_linestyle") == 0 ||
-				 strcmp(prev_wd, "unicode_column_linestyle") == 0 ||
-				 strcmp(prev_wd, "unicode_header_linestyle") == 0)
+		else if (strcmp(var, "unicode_border_linestyle") == 0 ||
+				 strcmp(var, "unicode_column_linestyle") == 0 ||
+				 strcmp(var, "unicode_header_linestyle") == 0)
 		{
 			static const char *const my_list[] =
 			{"single", "double", NULL};
@@ -4050,72 +3337,73 @@ psql_completion(const char *text, int start, int end)
 
 		}
 	}
-	else if (strcmp(prev_wd, "\\unset") == 0)
+	else if (REGMATCH(RE_meta_unset))
 	{
 		matches = complete_from_variables(text, "", "", true);
 	}
-	else if (strcmp(prev_wd, "\\set") == 0)
+	else if (REGMATCH(RE_meta_set))
 	{
 		matches = complete_from_variables(text, "", "", false);
 	}
-	else if (strcmp(prev2_wd, "\\set") == 0)
+	else if (REGMATCH(RE_meta_set_id))
 	{
 		static const char *const boolean_value_list[] =
 		{"on", "off", NULL};
+		char *var = CAPTURE(1);
 
-		if (strcmp(prev_wd, "AUTOCOMMIT") == 0)
+		if (strcmp(var, "AUTOCOMMIT") == 0)
 			COMPLETE_WITH_LIST_CS(boolean_value_list);
-		else if (strcmp(prev_wd, "COMP_KEYWORD_CASE") == 0)
+		else if (strcmp(var, "COMP_KEYWORD_CASE") == 0)
 		{
 			static const char *const my_list[] =
 			{"lower", "upper", "preserve-lower", "preserve-upper", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "ECHO") == 0)
+		else if (strcmp(var, "ECHO") == 0)
 		{
 			static const char *const my_list[] =
 			{"errors", "queries", "all", "none", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "ECHO_HIDDEN") == 0)
+		else if (strcmp(var, "ECHO_HIDDEN") == 0)
 		{
 			static const char *const my_list[] =
 			{"noexec", "off", "on", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "HISTCONTROL") == 0)
+		else if (strcmp(var, "HISTCONTROL") == 0)
 		{
 			static const char *const my_list[] =
 			{"ignorespace", "ignoredups", "ignoreboth", "none", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "ON_ERROR_ROLLBACK") == 0)
+		else if (strcmp(var, "ON_ERROR_ROLLBACK") == 0)
 		{
 			static const char *const my_list[] =
 			{"on", "off", "interactive", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "ON_ERROR_STOP") == 0)
+		else if (strcmp(var, "ON_ERROR_STOP") == 0)
 			COMPLETE_WITH_LIST_CS(boolean_value_list);
-		else if (strcmp(prev_wd, "QUIET") == 0)
+		else if (strcmp(var, "QUIET") == 0)
 			COMPLETE_WITH_LIST_CS(boolean_value_list);
-		else if (strcmp(prev_wd, "SHOW_CONTEXT") == 0)
+		else if (strcmp(var, "SHOW_CONTEXT") == 0)
 		{
 			static const char *const my_list[] =
 			{"never", "errors", "always", NULL};
 
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
-		else if (strcmp(prev_wd, "SINGLELINE") == 0)
+		else if (strcmp(var, "SINGLELINE") == 0)
 			COMPLETE_WITH_LIST_CS(boolean_value_list);
-		else if (strcmp(prev_wd, "SINGLESTEP") == 0)
+		else if (strcmp(var, "SINGLESTEP") == 0)
 			COMPLETE_WITH_LIST_CS(boolean_value_list);
-		else if (strcmp(prev_wd, "VERBOSITY") == 0)
+		else if (strcmp(var, "VERBOSITY") == 0)
 		{
 			static const char *const my_list[] =
 			{"default", "verbose", "terse", NULL};
@@ -4123,20 +3411,11 @@ psql_completion(const char *text, int start, int end)
 			COMPLETE_WITH_LIST_CS(my_list);
 		}
 	}
-	else if (strcmp(prev_wd, "\\sf") == 0 || strcmp(prev_wd, "\\sf+") == 0)
+	else if (REGMATCH(RE_meta_sf))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_functions, NULL);
-	else if (strcmp(prev_wd, "\\sv") == 0 || strcmp(prev_wd, "\\sv+") == 0)
+	else if (REGMATCH(RE_meta_sv))
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views, NULL);
-	else if (strcmp(prev_wd, "\\cd") == 0 ||
-			 strcmp(prev_wd, "\\e") == 0 || strcmp(prev_wd, "\\edit") == 0 ||
-			 strcmp(prev_wd, "\\g") == 0 ||
-		  strcmp(prev_wd, "\\i") == 0 || strcmp(prev_wd, "\\include") == 0 ||
-			 strcmp(prev_wd, "\\ir") == 0 || strcmp(prev_wd, "\\include_relative") == 0 ||
-			 strcmp(prev_wd, "\\o") == 0 || strcmp(prev_wd, "\\out") == 0 ||
-			 strcmp(prev_wd, "\\s") == 0 ||
-			 strcmp(prev_wd, "\\w") == 0 || strcmp(prev_wd, "\\write") == 0 ||
-			 strcmp(prev_wd, "\\lo_import") == 0
-		)
+	else if (REGMATCH(RE_meta_FILECMDS))
 	{
 		completion_charp = "\\";
 		matches = completion_matches(text, complete_from_files);
@@ -4147,13 +3426,14 @@ psql_completion(const char *text, int start, int end)
 	 * check if that was the previous word. If so, execute the query to get a
 	 * list of them.
 	 */
-	else
+	else if (REGMATCH(RE_AnySingleWord))
 	{
 		int			i;
+		char *thing = CAPTURE(1);
 
 		for (i = 0; words_after_create[i].name; i++)
 		{
-			if (pg_strcasecmp(prev_wd, words_after_create[i].name) == 0)
+			if (pg_strcasecmp(thing, words_after_create[i].name) == 0)
 			{
 				if (words_after_create[i].query)
 					COMPLETE_WITH_QUERY(words_after_create[i].query);
@@ -4178,14 +3458,6 @@ psql_completion(const char *text, int start, int end)
 #endif
 	}
 
-	/* free storage */
-	{
-		int			i;
-
-		for (i = 0; i < lengthof(previous_words); i++)
-			free(previous_words[i]);
-	}
-
 	/* Return our Grand List O' Matches */
 	return matches;
 }
@@ -4763,91 +4035,6 @@ exec_query(const char *query)
 
 
 /*
- * Return the nwords word(s) before point.  Words are returned right to left,
- * that is, previous_words[0] gets the last word before point.
- * If we run out of words, remaining array elements are set to empty strings.
- * Each array element is filled with a malloc'd string.
- */
-static void
-get_previous_words(int point, char **previous_words, int nwords)
-{
-	const char *buf = rl_line_buffer;	/* alias */
-	int			i;
-
-	/* first we look for a non-word char before the current point */
-	for (i = point - 1; i >= 0; i--)
-		if (strchr(WORD_BREAKS, buf[i]))
-			break;
-	point = i;
-
-	while (nwords-- > 0)
-	{
-		int			start,
-					end;
-		char	   *s;
-
-		/* now find the first non-space which then constitutes the end */
-		end = -1;
-		for (i = point; i >= 0; i--)
-		{
-			if (!isspace((unsigned char) buf[i]))
-			{
-				end = i;
-				break;
-			}
-		}
-
-		/*
-		 * If no end found we return an empty string, because there is no word
-		 * before the point
-		 */
-		if (end < 0)
-		{
-			point = end;
-			s = pg_strdup("");
-		}
-		else
-		{
-			/*
-			 * Otherwise we now look for the start. The start is either the
-			 * last character before any word-break character going backwards
-			 * from the end, or it's simply character 0. We also handle open
-			 * quotes and parentheses.
-			 */
-			bool		inquotes = false;
-			int			parentheses = 0;
-
-			for (start = end; start > 0; start--)
-			{
-				if (buf[start] == '"')
-					inquotes = !inquotes;
-				if (!inquotes)
-				{
-					if (buf[start] == ')')
-						parentheses++;
-					else if (buf[start] == '(')
-					{
-						if (--parentheses <= 0)
-							break;
-					}
-					else if (parentheses == 0 &&
-							 strchr(WORD_BREAKS, buf[start - 1]))
-						break;
-				}
-			}
-
-			point = start - 1;
-
-			/* make a copy of chars from start to end inclusive */
-			s = pg_malloc(end - start + 2);
-			strlcpy(s, &buf[start], end - start + 2);
-		}
-
-		*previous_words++ = s;
-	}
-}
-
-/*
  * Look up the type for the GUC variable with the passed name.
  *
  * Returns NULL if the variable is unknown. Otherwise the returned string,
-- 
1.8.3.1

