TLA Line data Source code
1 : /*
2 : * psql - the PostgreSQL interactive terminal
3 : *
4 : * Copyright (c) 2000-2023, PostgreSQL Global Development Group
5 : *
6 : * src/bin/psql/tab-complete.c
7 : */
8 :
9 : /*----------------------------------------------------------------------
10 : * This file implements a somewhat more sophisticated readline "TAB
11 : * completion" in psql. It is not intended to be AI, to replace
12 : * learning SQL, or to relieve you from thinking about what you're
13 : * doing. Also it does not always give you all the syntactically legal
14 : * completions, only those that are the most common or the ones that
15 : * the programmer felt most like implementing.
16 : *
17 : * CAVEAT: Tab completion causes queries to be sent to the backend.
18 : * The number of tuples returned gets limited, in most default
19 : * installations to 1000, but if you still don't like this prospect,
20 : * you can turn off tab completion in your ~/.inputrc (or else
21 : * ${INPUTRC}) file so:
22 : *
23 : * $if psql
24 : * set disable-completion on
25 : * $endif
26 : *
27 : * See `man 3 readline' or `info readline' for the full details.
28 : *
29 : * BUGS:
30 : * - Quotes, parentheses, and other funny characters are not handled
31 : * all that gracefully.
32 : *----------------------------------------------------------------------
33 : */
34 :
35 : #include "postgres_fe.h"
36 :
37 : #include "input.h"
38 : #include "tab-complete.h"
39 :
40 : /* If we don't have this, we might as well forget about the whole thing: */
41 : #ifdef USE_READLINE
42 :
43 : #include <ctype.h>
44 : #include <sys/stat.h>
45 :
46 : #include "catalog/pg_am_d.h"
47 : #include "catalog/pg_class_d.h"
48 : #include "common.h"
49 : #include "common/keywords.h"
50 : #include "libpq-fe.h"
51 : #include "mb/pg_wchar.h"
52 : #include "pqexpbuffer.h"
53 : #include "settings.h"
54 : #include "stringutils.h"
55 :
56 : /*
57 : * Ancient versions of libedit provide filename_completion_function()
58 : * instead of rl_filename_completion_function(). Likewise for
59 : * [rl_]completion_matches().
60 : */
61 : #ifndef HAVE_RL_FILENAME_COMPLETION_FUNCTION
62 : #define rl_filename_completion_function filename_completion_function
63 : #endif
64 :
65 : #ifndef HAVE_RL_COMPLETION_MATCHES
66 : #define rl_completion_matches completion_matches
67 : #endif
68 :
69 : /*
70 : * Currently we assume that rl_filename_dequoting_function exists if
71 : * rl_filename_quoting_function does. If that proves not to be the case,
72 : * we'd need to test for the former, or possibly both, in configure.
73 : */
74 : #ifdef HAVE_RL_FILENAME_QUOTING_FUNCTION
75 : #define USE_FILENAME_QUOTING_FUNCTIONS 1
76 : #endif
77 :
78 : /* word break characters */
79 : #define WORD_BREAKS "\t\n@$><=;|&{() "
80 :
81 : /*
82 : * Since readline doesn't let us pass any state through to the tab completion
83 : * callback, we have to use this global variable to let get_previous_words()
84 : * get at the previous lines of the current command. Ick.
85 : */
86 : PQExpBuffer tab_completion_query_buf = NULL;
87 :
88 : /*
89 : * In some situations, the query to find out what names are available to
90 : * complete with must vary depending on server version. We handle this by
91 : * storing a list of queries, each tagged with the minimum server version
92 : * it will work for. Each list must be stored in descending server version
93 : * order, so that the first satisfactory query is the one to use.
94 : *
95 : * When the query string is otherwise constant, an array of VersionedQuery
96 : * suffices. Terminate the array with an entry having min_server_version = 0.
97 : * That entry's query string can be a query that works in all supported older
98 : * server versions, or NULL to give up and do no completion.
99 : */
100 : typedef struct VersionedQuery
101 : {
102 : int min_server_version;
103 : const char *query;
104 : } VersionedQuery;
105 :
106 : /*
107 : * This struct is used to define "schema queries", which are custom-built
108 : * to obtain possibly-schema-qualified names of database objects. There is
109 : * enough similarity in the structure that we don't want to repeat it each
110 : * time. So we put the components of each query into this struct and
111 : * assemble them with the common boilerplate in _complete_from_query().
112 : *
113 : * We also use this struct to define queries that use completion_ref_object,
114 : * which is some object related to the one(s) we want to get the names of
115 : * (for example, the table we want the indexes of). In that usage the
116 : * objects we're completing might not have a schema of their own, but the
117 : * reference object almost always does (passed in completion_ref_schema).
118 : *
119 : * As with VersionedQuery, we can use an array of these if the query details
120 : * must vary across versions.
121 : */
122 : typedef struct SchemaQuery
123 : {
124 : /*
125 : * If not zero, minimum server version this struct applies to. If not
126 : * zero, there should be a following struct with a smaller minimum server
127 : * version; use catname == NULL in the last entry if we should do nothing.
128 : */
129 : int min_server_version;
130 :
131 : /*
132 : * Name of catalog or catalogs to be queried, with alias(es), eg.
133 : * "pg_catalog.pg_class c". Note that "pg_namespace n" and/or
134 : * "pg_namespace nr" will be added automatically when needed.
135 : */
136 : const char *catname;
137 :
138 : /*
139 : * Selection condition --- only rows meeting this condition are candidates
140 : * to display. If catname mentions multiple tables, include the necessary
141 : * join condition here. For example, this might look like "c.relkind = "
142 : * CppAsString2(RELKIND_RELATION). Write NULL (not an empty string) if
143 : * not needed.
144 : */
145 : const char *selcondition;
146 :
147 : /*
148 : * Visibility condition --- which rows are visible without schema
149 : * qualification? For example, "pg_catalog.pg_table_is_visible(c.oid)".
150 : * NULL if not needed.
151 : */
152 : const char *viscondition;
153 :
154 : /*
155 : * Namespace --- name of field to join to pg_namespace.oid when there is
156 : * schema qualification. For example, "c.relnamespace". NULL if we don't
157 : * want to join to pg_namespace (then any schema part in the input word
158 : * will be ignored).
159 : */
160 : const char *namespace;
161 :
162 : /*
163 : * Result --- the base object name to return. For example, "c.relname".
164 : */
165 : const char *result;
166 :
167 : /*
168 : * In some cases, it's difficult to keep the query from returning the same
169 : * object multiple times. Specify use_distinct to filter out duplicates.
170 : */
171 : bool use_distinct;
172 :
173 : /*
174 : * Additional literal strings (usually keywords) to be offered along with
175 : * the query results. Provide a NULL-terminated array of constant
176 : * strings, or NULL if none.
177 : */
178 : const char *const *keywords;
179 :
180 : /*
181 : * If this query uses completion_ref_object/completion_ref_schema,
182 : * populate the remaining fields, else leave them NULL. When using this
183 : * capability, catname must include the catalog that defines the
184 : * completion_ref_object, and selcondition must include the join condition
185 : * that connects it to the result's catalog.
186 : *
187 : * refname is the field that should be equated to completion_ref_object,
188 : * for example "cr.relname".
189 : */
190 : const char *refname;
191 :
192 : /*
193 : * Visibility condition to use when completion_ref_schema is not set. For
194 : * example, "pg_catalog.pg_table_is_visible(cr.oid)". NULL if not needed.
195 : */
196 : const char *refviscondition;
197 :
198 : /*
199 : * Name of field to join to pg_namespace.oid when completion_ref_schema is
200 : * set. For example, "cr.relnamespace". NULL if we don't want to
201 : * consider completion_ref_schema.
202 : */
203 : const char *refnamespace;
204 : } SchemaQuery;
205 :
206 :
207 : /* Store maximum number of records we want from database queries
208 : * (implemented via SELECT ... LIMIT xx).
209 : */
210 : static int completion_max_records;
211 :
212 : /*
213 : * Communication variables set by psql_completion (mostly in COMPLETE_WITH_FOO
214 : * macros) and then used by the completion callback functions. Ugly but there
215 : * is no better way.
216 : */
217 : static char completion_last_char; /* last char of input word */
218 : static const char *completion_charp; /* to pass a string */
219 : static const char *const *completion_charpp; /* to pass a list of strings */
220 : static const VersionedQuery *completion_vquery; /* to pass a VersionedQuery */
221 : static const SchemaQuery *completion_squery; /* to pass a SchemaQuery */
222 : static char *completion_ref_object; /* name of reference object */
223 : static char *completion_ref_schema; /* schema name of reference object */
224 : static bool completion_case_sensitive; /* completion is case sensitive */
225 : static bool completion_verbatim; /* completion is verbatim */
226 : static bool completion_force_quote; /* true to force-quote filenames */
227 :
228 : /*
229 : * A few macros to ease typing. You can use these to complete the given
230 : * string with
231 : * 1) The result from a query you pass it. (Perhaps one of those below?)
232 : * We support both simple and versioned queries.
233 : * 2) The result from a schema query you pass it.
234 : * We support both simple and versioned schema queries.
235 : * 3) The items from a null-pointer-terminated list (with or without
236 : * case-sensitive comparison); if the list is constant you can build it
237 : * with COMPLETE_WITH() or COMPLETE_WITH_CS(). The QUERY_LIST and
238 : * QUERY_PLUS forms combine such literal lists with a query result.
239 : * 4) The list of attributes of the given table (possibly schema-qualified).
240 : * 5) The list of arguments to the given function (possibly schema-qualified).
241 : *
242 : * The query is generally expected to return raw SQL identifiers; matching
243 : * to what the user typed is done in a quoting-aware fashion. If what is
244 : * returned is not SQL identifiers, use one of the VERBATIM forms, in which
245 : * case the query results are matched to the user's text without double-quote
246 : * processing (so if quoting is needed, you must provide it in the query
247 : * results).
248 : */
249 : #define COMPLETE_WITH_QUERY(query) \
250 : COMPLETE_WITH_QUERY_LIST(query, NULL)
251 :
252 : #define COMPLETE_WITH_QUERY_LIST(query, list) \
253 : do { \
254 : completion_charp = query; \
255 : completion_charpp = list; \
256 : completion_verbatim = false; \
257 : matches = rl_completion_matches(text, complete_from_query); \
258 : } while (0)
259 :
260 : #define COMPLETE_WITH_QUERY_PLUS(query, ...) \
261 : do { \
262 : static const char *const list[] = { __VA_ARGS__, NULL }; \
263 : COMPLETE_WITH_QUERY_LIST(query, list); \
264 : } while (0)
265 :
266 : #define COMPLETE_WITH_QUERY_VERBATIM(query) \
267 : COMPLETE_WITH_QUERY_VERBATIM_LIST(query, NULL)
268 :
269 : #define COMPLETE_WITH_QUERY_VERBATIM_LIST(query, list) \
270 : do { \
271 : completion_charp = query; \
272 : completion_charpp = list; \
273 : completion_verbatim = true; \
274 : matches = rl_completion_matches(text, complete_from_query); \
275 : } while (0)
276 :
277 : #define COMPLETE_WITH_QUERY_VERBATIM_PLUS(query, ...) \
278 : do { \
279 : static const char *const list[] = { __VA_ARGS__, NULL }; \
280 : COMPLETE_WITH_QUERY_VERBATIM_LIST(query, list); \
281 : } while (0)
282 :
283 : #define COMPLETE_WITH_VERSIONED_QUERY(query) \
284 : COMPLETE_WITH_VERSIONED_QUERY_LIST(query, NULL)
285 :
286 : #define COMPLETE_WITH_VERSIONED_QUERY_LIST(query, list) \
287 : do { \
288 : completion_vquery = query; \
289 : completion_charpp = list; \
290 : completion_verbatim = false; \
291 : matches = rl_completion_matches(text, complete_from_versioned_query); \
292 : } while (0)
293 :
294 : #define COMPLETE_WITH_VERSIONED_QUERY_PLUS(query, ...) \
295 : do { \
296 : static const char *const list[] = { __VA_ARGS__, NULL }; \
297 : COMPLETE_WITH_VERSIONED_QUERY_LIST(query, list); \
298 : } while (0)
299 :
300 : #define COMPLETE_WITH_SCHEMA_QUERY(query) \
301 : COMPLETE_WITH_SCHEMA_QUERY_LIST(query, NULL)
302 :
303 : #define COMPLETE_WITH_SCHEMA_QUERY_LIST(query, list) \
304 : do { \
305 : completion_squery = &(query); \
306 : completion_charpp = list; \
307 : completion_verbatim = false; \
308 : matches = rl_completion_matches(text, complete_from_schema_query); \
309 : } while (0)
310 :
311 : #define COMPLETE_WITH_SCHEMA_QUERY_PLUS(query, ...) \
312 : do { \
313 : static const char *const list[] = { __VA_ARGS__, NULL }; \
314 : COMPLETE_WITH_SCHEMA_QUERY_LIST(query, list); \
315 : } while (0)
316 :
317 : #define COMPLETE_WITH_SCHEMA_QUERY_VERBATIM(query) \
318 : do { \
319 : completion_squery = &(query); \
320 : completion_charpp = NULL; \
321 : completion_verbatim = true; \
322 : matches = rl_completion_matches(text, complete_from_schema_query); \
323 : } while (0)
324 :
325 : #define COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(query) \
326 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY_LIST(query, NULL)
327 :
328 : #define COMPLETE_WITH_VERSIONED_SCHEMA_QUERY_LIST(query, list) \
329 : do { \
330 : completion_squery = query; \
331 : completion_charpp = list; \
332 : completion_verbatim = false; \
333 : matches = rl_completion_matches(text, complete_from_versioned_schema_query); \
334 : } while (0)
335 :
336 : #define COMPLETE_WITH_VERSIONED_SCHEMA_QUERY_PLUS(query, ...) \
337 : do { \
338 : static const char *const list[] = { __VA_ARGS__, NULL }; \
339 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY_LIST(query, list); \
340 : } while (0)
341 :
342 : /*
343 : * Caution: COMPLETE_WITH_CONST is not for general-purpose use; you probably
344 : * want COMPLETE_WITH() with one element, instead.
345 : */
346 : #define COMPLETE_WITH_CONST(cs, con) \
347 : do { \
348 : completion_case_sensitive = (cs); \
349 : completion_charp = (con); \
350 : matches = rl_completion_matches(text, complete_from_const); \
351 : } while (0)
352 :
353 : #define COMPLETE_WITH_LIST_INT(cs, list) \
354 : do { \
355 : completion_case_sensitive = (cs); \
356 : completion_charpp = (list); \
357 : matches = rl_completion_matches(text, complete_from_list); \
358 : } while (0)
359 :
360 : #define COMPLETE_WITH_LIST(list) COMPLETE_WITH_LIST_INT(false, list)
361 : #define COMPLETE_WITH_LIST_CS(list) COMPLETE_WITH_LIST_INT(true, list)
362 :
363 : #define COMPLETE_WITH(...) \
364 : do { \
365 : static const char *const list[] = { __VA_ARGS__, NULL }; \
366 : COMPLETE_WITH_LIST(list); \
367 : } while (0)
368 :
369 : #define COMPLETE_WITH_CS(...) \
370 : do { \
371 : static const char *const list[] = { __VA_ARGS__, NULL }; \
372 : COMPLETE_WITH_LIST_CS(list); \
373 : } while (0)
374 :
375 : #define COMPLETE_WITH_ATTR(relation) \
376 : COMPLETE_WITH_ATTR_LIST(relation, NULL)
377 :
378 : #define COMPLETE_WITH_ATTR_LIST(relation, list) \
379 : do { \
380 : set_completion_reference(relation); \
381 : completion_squery = &(Query_for_list_of_attributes); \
382 : completion_charpp = list; \
383 : completion_verbatim = false; \
384 : matches = rl_completion_matches(text, complete_from_schema_query); \
385 : } while (0)
386 :
387 : #define COMPLETE_WITH_ATTR_PLUS(relation, ...) \
388 : do { \
389 : static const char *const list[] = { __VA_ARGS__, NULL }; \
390 : COMPLETE_WITH_ATTR_LIST(relation, list); \
391 : } while (0)
392 :
393 : /*
394 : * libedit will typically include the literal's leading single quote in
395 : * "text", while readline will not. Adapt our offered strings to fit.
396 : * But include a quote if there's not one just before "text", to get the
397 : * user off to the right start.
398 : */
399 : #define COMPLETE_WITH_ENUM_VALUE(type) \
400 : do { \
401 : set_completion_reference(type); \
402 : if (text[0] == '\'' || \
403 : start == 0 || rl_line_buffer[start - 1] != '\'') \
404 : completion_squery = &(Query_for_list_of_enum_values_quoted); \
405 : else \
406 : completion_squery = &(Query_for_list_of_enum_values_unquoted); \
407 : completion_charpp = NULL; \
408 : completion_verbatim = true; \
409 : matches = rl_completion_matches(text, complete_from_schema_query); \
410 : } while (0)
411 :
412 : /*
413 : * Timezone completion is mostly like enum label completion, but we work
414 : * a little harder since this is a more common use-case.
415 : */
416 : #define COMPLETE_WITH_TIMEZONE_NAME() \
417 : do { \
418 : static const char *const list[] = { "DEFAULT", NULL }; \
419 : if (text[0] == '\'') \
420 : completion_charp = Query_for_list_of_timezone_names_quoted_in; \
421 : else if (start == 0 || rl_line_buffer[start - 1] != '\'') \
422 : completion_charp = Query_for_list_of_timezone_names_quoted_out; \
423 : else \
424 : completion_charp = Query_for_list_of_timezone_names_unquoted; \
425 : completion_charpp = list; \
426 : completion_verbatim = true; \
427 : matches = rl_completion_matches(text, complete_from_query); \
428 : } while (0)
429 :
430 : #define COMPLETE_WITH_FUNCTION_ARG(function) \
431 : do { \
432 : set_completion_reference(function); \
433 : completion_squery = &(Query_for_list_of_arguments); \
434 : completion_charpp = NULL; \
435 : completion_verbatim = true; \
436 : matches = rl_completion_matches(text, complete_from_schema_query); \
437 : } while (0)
438 :
439 : /*
440 : * Assembly instructions for schema queries
441 : *
442 : * Note that toast tables are not included in those queries to avoid
443 : * unnecessary bloat in the completions generated.
444 : */
445 :
446 : static const SchemaQuery Query_for_constraint_of_table = {
447 : .catname = "pg_catalog.pg_constraint con, pg_catalog.pg_class c1",
448 : .selcondition = "con.conrelid=c1.oid",
449 : .result = "con.conname",
450 : .refname = "c1.relname",
451 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
452 : .refnamespace = "c1.relnamespace",
453 : };
454 :
455 : static const SchemaQuery Query_for_constraint_of_table_not_validated = {
456 : .catname = "pg_catalog.pg_constraint con, pg_catalog.pg_class c1",
457 : .selcondition = "con.conrelid=c1.oid and not con.convalidated",
458 : .result = "con.conname",
459 : .refname = "c1.relname",
460 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
461 : .refnamespace = "c1.relnamespace",
462 : };
463 :
464 : static const SchemaQuery Query_for_constraint_of_type = {
465 : .catname = "pg_catalog.pg_constraint con, pg_catalog.pg_type t",
466 : .selcondition = "con.contypid=t.oid",
467 : .result = "con.conname",
468 : .refname = "t.typname",
469 : .refviscondition = "pg_catalog.pg_type_is_visible(t.oid)",
470 : .refnamespace = "t.typnamespace",
471 : };
472 :
473 : static const SchemaQuery Query_for_index_of_table = {
474 : .catname = "pg_catalog.pg_class c1, pg_catalog.pg_class c2, pg_catalog.pg_index i",
475 : .selcondition = "c1.oid=i.indrelid and i.indexrelid=c2.oid",
476 : .result = "c2.relname",
477 : .refname = "c1.relname",
478 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
479 : .refnamespace = "c1.relnamespace",
480 : };
481 :
482 : static const SchemaQuery Query_for_unique_index_of_table = {
483 : .catname = "pg_catalog.pg_class c1, pg_catalog.pg_class c2, pg_catalog.pg_index i",
484 : .selcondition = "c1.oid=i.indrelid and i.indexrelid=c2.oid and i.indisunique",
485 : .result = "c2.relname",
486 : .refname = "c1.relname",
487 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
488 : .refnamespace = "c1.relnamespace",
489 : };
490 :
491 : static const SchemaQuery Query_for_list_of_aggregates[] = {
492 : {
493 : .min_server_version = 110000,
494 : .catname = "pg_catalog.pg_proc p",
495 : .selcondition = "p.prokind = 'a'",
496 : .viscondition = "pg_catalog.pg_function_is_visible(p.oid)",
497 : .namespace = "p.pronamespace",
498 : .result = "p.proname",
499 : },
500 : {
501 : .catname = "pg_catalog.pg_proc p",
502 : .selcondition = "p.proisagg",
503 : .viscondition = "pg_catalog.pg_function_is_visible(p.oid)",
504 : .namespace = "p.pronamespace",
505 : .result = "p.proname",
506 : }
507 : };
508 :
509 : static const SchemaQuery Query_for_list_of_arguments = {
510 : .catname = "pg_catalog.pg_proc p",
511 : .result = "pg_catalog.oidvectortypes(p.proargtypes)||')'",
512 : .refname = "p.proname",
513 : .refviscondition = "pg_catalog.pg_function_is_visible(p.oid)",
514 : .refnamespace = "p.pronamespace",
515 : };
516 :
517 : static const SchemaQuery Query_for_list_of_attributes = {
518 : .catname = "pg_catalog.pg_attribute a, pg_catalog.pg_class c",
519 : .selcondition = "c.oid = a.attrelid and a.attnum > 0 and not a.attisdropped",
520 : .result = "a.attname",
521 : .refname = "c.relname",
522 : .refviscondition = "pg_catalog.pg_table_is_visible(c.oid)",
523 : .refnamespace = "c.relnamespace",
524 : };
525 :
526 : static const SchemaQuery Query_for_list_of_attribute_numbers = {
527 : .catname = "pg_catalog.pg_attribute a, pg_catalog.pg_class c",
528 : .selcondition = "c.oid = a.attrelid and a.attnum > 0 and not a.attisdropped",
529 : .result = "a.attnum::pg_catalog.text",
530 : .refname = "c.relname",
531 : .refviscondition = "pg_catalog.pg_table_is_visible(c.oid)",
532 : .refnamespace = "c.relnamespace",
533 : };
534 :
535 : static const char *const Keywords_for_list_of_datatypes[] = {
536 : "bigint",
537 : "boolean",
538 : "character",
539 : "double precision",
540 : "integer",
541 : "real",
542 : "smallint",
543 :
544 : /*
545 : * Note: currently there's no value in offering the following multiword
546 : * type names, because tab completion cannot succeed for them: we can't
547 : * disambiguate until somewhere in the second word, at which point we
548 : * won't have the first word as context. ("double precision" does work,
549 : * as long as no other type name begins with "double".) Leave them out to
550 : * encourage users to use the PG-specific aliases, which we can complete.
551 : */
552 : #ifdef NOT_USED
553 : "bit varying",
554 : "character varying",
555 : "time with time zone",
556 : "time without time zone",
557 : "timestamp with time zone",
558 : "timestamp without time zone",
559 : #endif
560 : NULL
561 : };
562 :
563 : static const SchemaQuery Query_for_list_of_datatypes = {
564 : .catname = "pg_catalog.pg_type t",
565 : /* selcondition --- ignore table rowtypes and array types */
566 : .selcondition = "(t.typrelid = 0 "
567 : " OR (SELECT c.relkind = " CppAsString2(RELKIND_COMPOSITE_TYPE)
568 : " FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)) "
569 : "AND t.typname !~ '^_'",
570 : .viscondition = "pg_catalog.pg_type_is_visible(t.oid)",
571 : .namespace = "t.typnamespace",
572 : .result = "t.typname",
573 : .keywords = Keywords_for_list_of_datatypes,
574 : };
575 :
576 : static const SchemaQuery Query_for_list_of_composite_datatypes = {
577 : .catname = "pg_catalog.pg_type t",
578 : /* selcondition --- only get composite types */
579 : .selcondition = "(SELECT c.relkind = " CppAsString2(RELKIND_COMPOSITE_TYPE)
580 : " FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid) "
581 : "AND t.typname !~ '^_'",
582 : .viscondition = "pg_catalog.pg_type_is_visible(t.oid)",
583 : .namespace = "t.typnamespace",
584 : .result = "t.typname",
585 : };
586 :
587 : static const SchemaQuery Query_for_list_of_domains = {
588 : .catname = "pg_catalog.pg_type t",
589 : .selcondition = "t.typtype = 'd'",
590 : .viscondition = "pg_catalog.pg_type_is_visible(t.oid)",
591 : .namespace = "t.typnamespace",
592 : .result = "t.typname",
593 : };
594 :
595 : static const SchemaQuery Query_for_list_of_enum_values_quoted = {
596 : .catname = "pg_catalog.pg_enum e, pg_catalog.pg_type t",
597 : .selcondition = "t.oid = e.enumtypid",
598 : .result = "pg_catalog.quote_literal(enumlabel)",
599 : .refname = "t.typname",
600 : .refviscondition = "pg_catalog.pg_type_is_visible(t.oid)",
601 : .refnamespace = "t.typnamespace",
602 : };
603 :
604 : static const SchemaQuery Query_for_list_of_enum_values_unquoted = {
605 : .catname = "pg_catalog.pg_enum e, pg_catalog.pg_type t",
606 : .selcondition = "t.oid = e.enumtypid",
607 : .result = "e.enumlabel",
608 : .refname = "t.typname",
609 : .refviscondition = "pg_catalog.pg_type_is_visible(t.oid)",
610 : .refnamespace = "t.typnamespace",
611 : };
612 :
613 : /* Note: this intentionally accepts aggregates as well as plain functions */
614 : static const SchemaQuery Query_for_list_of_functions[] = {
615 : {
616 : .min_server_version = 110000,
617 : .catname = "pg_catalog.pg_proc p",
618 : .selcondition = "p.prokind != 'p'",
619 : .viscondition = "pg_catalog.pg_function_is_visible(p.oid)",
620 : .namespace = "p.pronamespace",
621 : .result = "p.proname",
622 : },
623 : {
624 : .catname = "pg_catalog.pg_proc p",
625 : .viscondition = "pg_catalog.pg_function_is_visible(p.oid)",
626 : .namespace = "p.pronamespace",
627 : .result = "p.proname",
628 : }
629 : };
630 :
631 : static const SchemaQuery Query_for_list_of_procedures[] = {
632 : {
633 : .min_server_version = 110000,
634 : .catname = "pg_catalog.pg_proc p",
635 : .selcondition = "p.prokind = 'p'",
636 : .viscondition = "pg_catalog.pg_function_is_visible(p.oid)",
637 : .namespace = "p.pronamespace",
638 : .result = "p.proname",
639 : },
640 : {
641 : /* not supported in older versions */
642 : .catname = NULL,
643 : }
644 : };
645 :
646 : static const SchemaQuery Query_for_list_of_routines = {
647 : .catname = "pg_catalog.pg_proc p",
648 : .viscondition = "pg_catalog.pg_function_is_visible(p.oid)",
649 : .namespace = "p.pronamespace",
650 : .result = "p.proname",
651 : };
652 :
653 : static const SchemaQuery Query_for_list_of_sequences = {
654 : .catname = "pg_catalog.pg_class c",
655 : .selcondition = "c.relkind IN (" CppAsString2(RELKIND_SEQUENCE) ")",
656 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
657 : .namespace = "c.relnamespace",
658 : .result = "c.relname",
659 : };
660 :
661 : static const SchemaQuery Query_for_list_of_foreign_tables = {
662 : .catname = "pg_catalog.pg_class c",
663 : .selcondition = "c.relkind IN (" CppAsString2(RELKIND_FOREIGN_TABLE) ")",
664 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
665 : .namespace = "c.relnamespace",
666 : .result = "c.relname",
667 : };
668 :
669 : static const SchemaQuery Query_for_list_of_tables = {
670 : .catname = "pg_catalog.pg_class c",
671 : .selcondition =
672 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
673 : CppAsString2(RELKIND_PARTITIONED_TABLE) ")",
674 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
675 : .namespace = "c.relnamespace",
676 : .result = "c.relname",
677 : };
678 :
679 : static const SchemaQuery Query_for_list_of_partitioned_tables = {
680 : .catname = "pg_catalog.pg_class c",
681 : .selcondition = "c.relkind IN (" CppAsString2(RELKIND_PARTITIONED_TABLE) ")",
682 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
683 : .namespace = "c.relnamespace",
684 : .result = "c.relname",
685 : };
686 :
687 : static const SchemaQuery Query_for_list_of_tables_for_constraint = {
688 : .catname = "pg_catalog.pg_class c, pg_catalog.pg_constraint con",
689 : .selcondition = "c.oid=con.conrelid and c.relkind IN ("
690 : CppAsString2(RELKIND_RELATION) ", "
691 : CppAsString2(RELKIND_PARTITIONED_TABLE) ")",
692 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
693 : .namespace = "c.relnamespace",
694 : .result = "c.relname",
695 : .use_distinct = true,
696 : .refname = "con.conname",
697 : };
698 :
699 : static const SchemaQuery Query_for_list_of_tables_for_policy = {
700 : .catname = "pg_catalog.pg_class c, pg_catalog.pg_policy p",
701 : .selcondition = "c.oid=p.polrelid",
702 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
703 : .namespace = "c.relnamespace",
704 : .result = "c.relname",
705 : .use_distinct = true,
706 : .refname = "p.polname",
707 : };
708 :
709 : static const SchemaQuery Query_for_list_of_tables_for_rule = {
710 : .catname = "pg_catalog.pg_class c, pg_catalog.pg_rewrite r",
711 : .selcondition = "c.oid=r.ev_class",
712 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
713 : .namespace = "c.relnamespace",
714 : .result = "c.relname",
715 : .use_distinct = true,
716 : .refname = "r.rulename",
717 : };
718 :
719 : static const SchemaQuery Query_for_list_of_tables_for_trigger = {
720 : .catname = "pg_catalog.pg_class c, pg_catalog.pg_trigger t",
721 : .selcondition = "c.oid=t.tgrelid",
722 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
723 : .namespace = "c.relnamespace",
724 : .result = "c.relname",
725 : .use_distinct = true,
726 : .refname = "t.tgname",
727 : };
728 :
729 : static const SchemaQuery Query_for_list_of_ts_configurations = {
730 : .catname = "pg_catalog.pg_ts_config c",
731 : .viscondition = "pg_catalog.pg_ts_config_is_visible(c.oid)",
732 : .namespace = "c.cfgnamespace",
733 : .result = "c.cfgname",
734 : };
735 :
736 : static const SchemaQuery Query_for_list_of_ts_dictionaries = {
737 : .catname = "pg_catalog.pg_ts_dict d",
738 : .viscondition = "pg_catalog.pg_ts_dict_is_visible(d.oid)",
739 : .namespace = "d.dictnamespace",
740 : .result = "d.dictname",
741 : };
742 :
743 : static const SchemaQuery Query_for_list_of_ts_parsers = {
744 : .catname = "pg_catalog.pg_ts_parser p",
745 : .viscondition = "pg_catalog.pg_ts_parser_is_visible(p.oid)",
746 : .namespace = "p.prsnamespace",
747 : .result = "p.prsname",
748 : };
749 :
750 : static const SchemaQuery Query_for_list_of_ts_templates = {
751 : .catname = "pg_catalog.pg_ts_template t",
752 : .viscondition = "pg_catalog.pg_ts_template_is_visible(t.oid)",
753 : .namespace = "t.tmplnamespace",
754 : .result = "t.tmplname",
755 : };
756 :
757 : static const SchemaQuery Query_for_list_of_views = {
758 : .catname = "pg_catalog.pg_class c",
759 : .selcondition = "c.relkind IN (" CppAsString2(RELKIND_VIEW) ")",
760 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
761 : .namespace = "c.relnamespace",
762 : .result = "c.relname",
763 : };
764 :
765 : static const SchemaQuery Query_for_list_of_matviews = {
766 : .catname = "pg_catalog.pg_class c",
767 : .selcondition = "c.relkind IN (" CppAsString2(RELKIND_MATVIEW) ")",
768 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
769 : .namespace = "c.relnamespace",
770 : .result = "c.relname",
771 : };
772 :
773 : static const SchemaQuery Query_for_list_of_indexes = {
774 : .catname = "pg_catalog.pg_class c",
775 : .selcondition =
776 : "c.relkind IN (" CppAsString2(RELKIND_INDEX) ", "
777 : CppAsString2(RELKIND_PARTITIONED_INDEX) ")",
778 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
779 : .namespace = "c.relnamespace",
780 : .result = "c.relname",
781 : };
782 :
783 : static const SchemaQuery Query_for_list_of_partitioned_indexes = {
784 : .catname = "pg_catalog.pg_class c",
785 : .selcondition = "c.relkind = " CppAsString2(RELKIND_PARTITIONED_INDEX),
786 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
787 : .namespace = "c.relnamespace",
788 : .result = "c.relname",
789 : };
790 :
791 :
792 : /* All relations */
793 : static const SchemaQuery Query_for_list_of_relations = {
794 : .catname = "pg_catalog.pg_class c",
795 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
796 : .namespace = "c.relnamespace",
797 : .result = "c.relname",
798 : };
799 :
800 : /* partitioned relations */
801 : static const SchemaQuery Query_for_list_of_partitioned_relations = {
802 : .catname = "pg_catalog.pg_class c",
803 : .selcondition = "c.relkind IN (" CppAsString2(RELKIND_PARTITIONED_TABLE)
804 : ", " CppAsString2(RELKIND_PARTITIONED_INDEX) ")",
805 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
806 : .namespace = "c.relnamespace",
807 : .result = "c.relname",
808 : };
809 :
810 : static const SchemaQuery Query_for_list_of_operator_families = {
811 : .catname = "pg_catalog.pg_opfamily c",
812 : .viscondition = "pg_catalog.pg_opfamily_is_visible(c.oid)",
813 : .namespace = "c.opfnamespace",
814 : .result = "c.opfname",
815 : };
816 :
817 : /* Relations supporting INSERT, UPDATE or DELETE */
818 : static const SchemaQuery Query_for_list_of_updatables = {
819 : .catname = "pg_catalog.pg_class c",
820 : .selcondition =
821 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
822 : CppAsString2(RELKIND_FOREIGN_TABLE) ", "
823 : CppAsString2(RELKIND_VIEW) ", "
824 : CppAsString2(RELKIND_PARTITIONED_TABLE) ")",
825 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
826 : .namespace = "c.relnamespace",
827 : .result = "c.relname",
828 : };
829 :
830 : /* Relations supporting MERGE */
831 : static const SchemaQuery Query_for_list_of_mergetargets = {
832 : .catname = "pg_catalog.pg_class c",
833 : .selcondition =
834 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
835 : CppAsString2(RELKIND_PARTITIONED_TABLE) ") ",
836 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
837 : .namespace = "c.relnamespace",
838 : .result = "c.relname",
839 : };
840 :
841 : /* Relations supporting SELECT */
842 : static const SchemaQuery Query_for_list_of_selectables = {
843 : .catname = "pg_catalog.pg_class c",
844 : .selcondition =
845 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
846 : CppAsString2(RELKIND_SEQUENCE) ", "
847 : CppAsString2(RELKIND_VIEW) ", "
848 : CppAsString2(RELKIND_MATVIEW) ", "
849 : CppAsString2(RELKIND_FOREIGN_TABLE) ", "
850 : CppAsString2(RELKIND_PARTITIONED_TABLE) ")",
851 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
852 : .namespace = "c.relnamespace",
853 : .result = "c.relname",
854 : };
855 :
856 : /* Relations supporting TRUNCATE */
857 : static const SchemaQuery Query_for_list_of_truncatables = {
858 : .catname = "pg_catalog.pg_class c",
859 : .selcondition =
860 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
861 : CppAsString2(RELKIND_FOREIGN_TABLE) ", "
862 : CppAsString2(RELKIND_PARTITIONED_TABLE) ")",
863 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
864 : .namespace = "c.relnamespace",
865 : .result = "c.relname",
866 : };
867 :
868 : /* Relations supporting GRANT are currently same as those supporting SELECT */
869 : #define Query_for_list_of_grantables Query_for_list_of_selectables
870 :
871 : /* Relations supporting ANALYZE */
872 : static const SchemaQuery Query_for_list_of_analyzables = {
873 : .catname = "pg_catalog.pg_class c",
874 : .selcondition =
875 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
876 : CppAsString2(RELKIND_PARTITIONED_TABLE) ", "
877 : CppAsString2(RELKIND_MATVIEW) ", "
878 : CppAsString2(RELKIND_FOREIGN_TABLE) ")",
879 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
880 : .namespace = "c.relnamespace",
881 : .result = "c.relname",
882 : };
883 :
884 : /* Relations supporting index creation */
885 : static const SchemaQuery Query_for_list_of_indexables = {
886 : .catname = "pg_catalog.pg_class c",
887 : .selcondition =
888 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
889 : CppAsString2(RELKIND_PARTITIONED_TABLE) ", "
890 : CppAsString2(RELKIND_MATVIEW) ")",
891 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
892 : .namespace = "c.relnamespace",
893 : .result = "c.relname",
894 : };
895 :
896 : /*
897 : * Relations supporting VACUUM are currently same as those supporting
898 : * indexing.
899 : */
900 : #define Query_for_list_of_vacuumables Query_for_list_of_indexables
901 :
902 : /* Relations supporting CLUSTER */
903 : static const SchemaQuery Query_for_list_of_clusterables = {
904 : .catname = "pg_catalog.pg_class c",
905 : .selcondition =
906 : "c.relkind IN (" CppAsString2(RELKIND_RELATION) ", "
907 : CppAsString2(RELKIND_PARTITIONED_TABLE) ", "
908 : CppAsString2(RELKIND_MATVIEW) ")",
909 : .viscondition = "pg_catalog.pg_table_is_visible(c.oid)",
910 : .namespace = "c.relnamespace",
911 : .result = "c.relname",
912 : };
913 :
914 : static const SchemaQuery Query_for_list_of_constraints_with_schema = {
915 : .catname = "pg_catalog.pg_constraint c",
916 : .selcondition = "c.conrelid <> 0",
917 : .namespace = "c.connamespace",
918 : .result = "c.conname",
919 : };
920 :
921 : static const SchemaQuery Query_for_list_of_statistics = {
922 : .catname = "pg_catalog.pg_statistic_ext s",
923 : .viscondition = "pg_catalog.pg_statistics_obj_is_visible(s.oid)",
924 : .namespace = "s.stxnamespace",
925 : .result = "s.stxname",
926 : };
927 :
928 : static const SchemaQuery Query_for_list_of_collations = {
929 : .catname = "pg_catalog.pg_collation c",
930 : .selcondition = "c.collencoding IN (-1, pg_catalog.pg_char_to_encoding(pg_catalog.getdatabaseencoding()))",
931 : .viscondition = "pg_catalog.pg_collation_is_visible(c.oid)",
932 : .namespace = "c.collnamespace",
933 : .result = "c.collname",
934 : };
935 :
936 : static const SchemaQuery Query_for_partition_of_table = {
937 : .catname = "pg_catalog.pg_class c1, pg_catalog.pg_class c2, pg_catalog.pg_inherits i",
938 : .selcondition = "c1.oid=i.inhparent and i.inhrelid=c2.oid and c2.relispartition",
939 : .viscondition = "pg_catalog.pg_table_is_visible(c2.oid)",
940 : .namespace = "c2.relnamespace",
941 : .result = "c2.relname",
942 : .refname = "c1.relname",
943 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
944 : .refnamespace = "c1.relnamespace",
945 : };
946 :
947 : static const SchemaQuery Query_for_rule_of_table = {
948 : .catname = "pg_catalog.pg_rewrite r, pg_catalog.pg_class c1",
949 : .selcondition = "r.ev_class=c1.oid",
950 : .result = "r.rulename",
951 : .refname = "c1.relname",
952 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
953 : .refnamespace = "c1.relnamespace",
954 : };
955 :
956 : static const SchemaQuery Query_for_trigger_of_table = {
957 : .catname = "pg_catalog.pg_trigger t, pg_catalog.pg_class c1",
958 : .selcondition = "t.tgrelid=c1.oid and not t.tgisinternal",
959 : .result = "t.tgname",
960 : .refname = "c1.relname",
961 : .refviscondition = "pg_catalog.pg_table_is_visible(c1.oid)",
962 : .refnamespace = "c1.relnamespace",
963 : };
964 :
965 :
966 : /*
967 : * Queries to get lists of names of various kinds of things, possibly
968 : * restricted to names matching a partially entered name. Don't use
969 : * this method where the user might wish to enter a schema-qualified
970 : * name; make a SchemaQuery instead.
971 : *
972 : * In these queries, there must be a restriction clause of the form
973 : * output LIKE '%s'
974 : * where "output" is the same string that the query returns. The %s
975 : * will be replaced by a LIKE pattern to match the already-typed text.
976 : *
977 : * There can be a second '%s', which will be replaced by a suitably-escaped
978 : * version of the string provided in completion_ref_object. If there is a
979 : * third '%s', it will be replaced by a suitably-escaped version of the string
980 : * provided in completion_ref_schema. NOTE: using completion_ref_object
981 : * that way is usually the wrong thing, and using completion_ref_schema
982 : * that way is always the wrong thing. Make a SchemaQuery instead.
983 : */
984 :
985 : #define Query_for_list_of_template_databases \
986 : "SELECT d.datname "\
987 : " FROM pg_catalog.pg_database d "\
988 : " WHERE d.datname LIKE '%s' "\
989 : " AND (d.datistemplate OR pg_catalog.pg_has_role(d.datdba, 'USAGE'))"
990 :
991 : #define Query_for_list_of_databases \
992 : "SELECT datname FROM pg_catalog.pg_database "\
993 : " WHERE datname LIKE '%s'"
994 :
995 : #define Query_for_list_of_tablespaces \
996 : "SELECT spcname FROM pg_catalog.pg_tablespace "\
997 : " WHERE spcname LIKE '%s'"
998 :
999 : #define Query_for_list_of_encodings \
1000 : " SELECT DISTINCT pg_catalog.pg_encoding_to_char(conforencoding) "\
1001 : " FROM pg_catalog.pg_conversion "\
1002 : " WHERE pg_catalog.pg_encoding_to_char(conforencoding) LIKE pg_catalog.upper('%s')"
1003 :
1004 : #define Query_for_list_of_languages \
1005 : "SELECT lanname "\
1006 : " FROM pg_catalog.pg_language "\
1007 : " WHERE lanname != 'internal' "\
1008 : " AND lanname LIKE '%s'"
1009 :
1010 : #define Query_for_list_of_schemas \
1011 : "SELECT nspname FROM pg_catalog.pg_namespace "\
1012 : " WHERE nspname LIKE '%s'"
1013 :
1014 : /* Use COMPLETE_WITH_QUERY_VERBATIM with these queries for GUC names: */
1015 : #define Query_for_list_of_alter_system_set_vars \
1016 : "SELECT pg_catalog.lower(name) FROM pg_catalog.pg_settings "\
1017 : " WHERE context != 'internal' "\
1018 : " AND pg_catalog.lower(name) LIKE pg_catalog.lower('%s')"
1019 :
1020 : #define Query_for_list_of_set_vars \
1021 : "SELECT pg_catalog.lower(name) FROM pg_catalog.pg_settings "\
1022 : " WHERE context IN ('user', 'superuser') "\
1023 : " AND pg_catalog.lower(name) LIKE pg_catalog.lower('%s')"
1024 :
1025 : #define Query_for_list_of_show_vars \
1026 : "SELECT pg_catalog.lower(name) FROM pg_catalog.pg_settings "\
1027 : " WHERE pg_catalog.lower(name) LIKE pg_catalog.lower('%s')"
1028 :
1029 : #define Query_for_list_of_roles \
1030 : " SELECT rolname "\
1031 : " FROM pg_catalog.pg_roles "\
1032 : " WHERE rolname LIKE '%s'"
1033 :
1034 : /* add these to Query_for_list_of_roles in GRANT contexts */
1035 : #define Keywords_for_list_of_grant_roles \
1036 : "PUBLIC", "CURRENT_ROLE", "CURRENT_USER", "SESSION_USER"
1037 :
1038 : #define Query_for_all_table_constraints \
1039 : "SELECT conname "\
1040 : " FROM pg_catalog.pg_constraint c "\
1041 : " WHERE c.conrelid <> 0 "\
1042 : " and conname LIKE '%s'"
1043 :
1044 : #define Query_for_list_of_fdws \
1045 : " SELECT fdwname "\
1046 : " FROM pg_catalog.pg_foreign_data_wrapper "\
1047 : " WHERE fdwname LIKE '%s'"
1048 :
1049 : #define Query_for_list_of_servers \
1050 : " SELECT srvname "\
1051 : " FROM pg_catalog.pg_foreign_server "\
1052 : " WHERE srvname LIKE '%s'"
1053 :
1054 : #define Query_for_list_of_user_mappings \
1055 : " SELECT usename "\
1056 : " FROM pg_catalog.pg_user_mappings "\
1057 : " WHERE usename LIKE '%s'"
1058 :
1059 : #define Query_for_list_of_access_methods \
1060 : " SELECT amname "\
1061 : " FROM pg_catalog.pg_am "\
1062 : " WHERE amname LIKE '%s'"
1063 :
1064 : #define Query_for_list_of_index_access_methods \
1065 : " SELECT amname "\
1066 : " FROM pg_catalog.pg_am "\
1067 : " WHERE amname LIKE '%s' AND "\
1068 : " amtype=" CppAsString2(AMTYPE_INDEX)
1069 :
1070 : #define Query_for_list_of_table_access_methods \
1071 : " SELECT amname "\
1072 : " FROM pg_catalog.pg_am "\
1073 : " WHERE amname LIKE '%s' AND "\
1074 : " amtype=" CppAsString2(AMTYPE_TABLE)
1075 :
1076 : #define Query_for_list_of_extensions \
1077 : " SELECT extname "\
1078 : " FROM pg_catalog.pg_extension "\
1079 : " WHERE extname LIKE '%s'"
1080 :
1081 : #define Query_for_list_of_available_extensions \
1082 : " SELECT name "\
1083 : " FROM pg_catalog.pg_available_extensions "\
1084 : " WHERE name LIKE '%s' AND installed_version IS NULL"
1085 :
1086 : #define Query_for_list_of_available_extension_versions \
1087 : " SELECT version "\
1088 : " FROM pg_catalog.pg_available_extension_versions "\
1089 : " WHERE version LIKE '%s' AND name='%s'"
1090 :
1091 : #define Query_for_list_of_prepared_statements \
1092 : " SELECT name "\
1093 : " FROM pg_catalog.pg_prepared_statements "\
1094 : " WHERE name LIKE '%s'"
1095 :
1096 : #define Query_for_list_of_event_triggers \
1097 : " SELECT evtname "\
1098 : " FROM pg_catalog.pg_event_trigger "\
1099 : " WHERE evtname LIKE '%s'"
1100 :
1101 : #define Query_for_list_of_tablesample_methods \
1102 : " SELECT proname "\
1103 : " FROM pg_catalog.pg_proc "\
1104 : " WHERE prorettype = 'pg_catalog.tsm_handler'::pg_catalog.regtype AND "\
1105 : " proargtypes[0] = 'pg_catalog.internal'::pg_catalog.regtype AND "\
1106 : " proname LIKE '%s'"
1107 :
1108 : #define Query_for_list_of_policies \
1109 : " SELECT polname "\
1110 : " FROM pg_catalog.pg_policy "\
1111 : " WHERE polname LIKE '%s'"
1112 :
1113 : #define Query_for_values_of_enum_GUC \
1114 : " SELECT val FROM ( "\
1115 : " SELECT name, pg_catalog.unnest(enumvals) AS val "\
1116 : " FROM pg_catalog.pg_settings "\
1117 : " ) ss "\
1118 : " WHERE val LIKE '%s'"\
1119 : " and pg_catalog.lower(name)=pg_catalog.lower('%s')"
1120 :
1121 : #define Query_for_list_of_channels \
1122 : " SELECT channel "\
1123 : " FROM pg_catalog.pg_listening_channels() AS channel "\
1124 : " WHERE channel LIKE '%s'"
1125 :
1126 : #define Query_for_list_of_cursors \
1127 : " SELECT name "\
1128 : " FROM pg_catalog.pg_cursors "\
1129 : " WHERE name LIKE '%s'"
1130 :
1131 : #define Query_for_list_of_timezone_names_unquoted \
1132 : " SELECT name "\
1133 : " FROM pg_catalog.pg_timezone_names() "\
1134 : " WHERE pg_catalog.lower(name) LIKE pg_catalog.lower('%s')"
1135 :
1136 : #define Query_for_list_of_timezone_names_quoted_out \
1137 : "SELECT pg_catalog.quote_literal(name) AS name "\
1138 : " FROM pg_catalog.pg_timezone_names() "\
1139 : " WHERE pg_catalog.lower(name) LIKE pg_catalog.lower('%s')"
1140 :
1141 : #define Query_for_list_of_timezone_names_quoted_in \
1142 : "SELECT pg_catalog.quote_literal(name) AS name "\
1143 : " FROM pg_catalog.pg_timezone_names() "\
1144 : " WHERE pg_catalog.quote_literal(pg_catalog.lower(name)) LIKE pg_catalog.lower('%s')"
1145 :
1146 : /* Privilege options shared between GRANT and REVOKE */
1147 : #define Privilege_options_of_grant_and_revoke \
1148 : "SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", \
1149 : "CREATE", "CONNECT", "TEMPORARY", "EXECUTE", "USAGE", "SET", "ALTER SYSTEM", \
1150 : "MAINTAIN", "ALL"
1151 :
1152 : /* ALTER PROCEDURE options */
1153 : #define Alter_procedure_options \
1154 : "DEPENDS ON EXTENSION", "EXTERNAL SECURITY", "NO DEPENDS ON EXTENSION", \
1155 : "OWNER TO", "RENAME TO", "RESET", "SECURITY", "SET"
1156 :
1157 : /* ALTER ROUTINE options */
1158 : #define Alter_routine_options \
1159 : Alter_procedure_options, "COST", "IMMUTABLE", "LEAKPROOF", "NOT LEAKPROOF", \
1160 : "PARALLEL", "ROWS", "STABLE", "VOLATILE"
1161 :
1162 : /* ALTER FUNCTION options */
1163 : #define Alter_function_options \
1164 : Alter_routine_options, "CALLED ON NULL INPUT", "RETURNS NULL ON NULL INPUT", \
1165 : "STRICT", "SUPPORT"
1166 :
1167 : /*
1168 : * These object types were introduced later than our support cutoff of
1169 : * server version 9.2. We use the VersionedQuery infrastructure so that
1170 : * we don't send certain-to-fail queries to older servers.
1171 : */
1172 :
1173 : static const VersionedQuery Query_for_list_of_publications[] = {
1174 : {100000,
1175 : " SELECT pubname "
1176 : " FROM pg_catalog.pg_publication "
1177 : " WHERE pubname LIKE '%s'"
1178 : },
1179 : {0, NULL}
1180 : };
1181 :
1182 : static const VersionedQuery Query_for_list_of_subscriptions[] = {
1183 : {100000,
1184 : " SELECT s.subname "
1185 : " FROM pg_catalog.pg_subscription s, pg_catalog.pg_database d "
1186 : " WHERE s.subname LIKE '%s' "
1187 : " AND d.datname = pg_catalog.current_database() "
1188 : " AND s.subdbid = d.oid"
1189 : },
1190 : {0, NULL}
1191 : };
1192 :
1193 : /*
1194 : * This is a list of all "things" in Pgsql, which can show up after CREATE or
1195 : * DROP; and there is also a query to get a list of them.
1196 : */
1197 :
1198 : typedef struct
1199 : {
1200 : const char *name;
1201 : /* Provide at most one of these three types of query: */
1202 : const char *query; /* simple query, or NULL */
1203 : const VersionedQuery *vquery; /* versioned query, or NULL */
1204 : const SchemaQuery *squery; /* schema query, or NULL */
1205 : const char *const *keywords; /* keywords to be offered as well */
1206 : const bits32 flags; /* visibility flags, see below */
1207 : } pgsql_thing_t;
1208 :
1209 : #define THING_NO_CREATE (1 << 0) /* should not show up after CREATE */
1210 : #define THING_NO_DROP (1 << 1) /* should not show up after DROP */
1211 : #define THING_NO_ALTER (1 << 2) /* should not show up after ALTER */
1212 : #define THING_NO_SHOW (THING_NO_CREATE | THING_NO_DROP | THING_NO_ALTER)
1213 :
1214 : /* When we have DROP USER etc, also offer MAPPING FOR */
1215 : static const char *const Keywords_for_user_thing[] = {
1216 : "MAPPING FOR",
1217 : NULL
1218 : };
1219 :
1220 : static const pgsql_thing_t words_after_create[] = {
1221 : {"ACCESS METHOD", NULL, NULL, NULL, NULL, THING_NO_ALTER},
1222 : {"AGGREGATE", NULL, NULL, Query_for_list_of_aggregates},
1223 : {"CAST", NULL, NULL, NULL}, /* Casts have complex structures for names, so
1224 : * skip it */
1225 : {"COLLATION", NULL, NULL, &Query_for_list_of_collations},
1226 :
1227 : /*
1228 : * CREATE CONSTRAINT TRIGGER is not supported here because it is designed
1229 : * to be used only by pg_dump.
1230 : */
1231 : {"CONFIGURATION", NULL, NULL, &Query_for_list_of_ts_configurations, NULL, THING_NO_SHOW},
1232 : {"CONVERSION", "SELECT conname FROM pg_catalog.pg_conversion WHERE conname LIKE '%s'"},
1233 : {"DATABASE", Query_for_list_of_databases},
1234 : {"DEFAULT PRIVILEGES", NULL, NULL, NULL, NULL, THING_NO_CREATE | THING_NO_DROP},
1235 : {"DICTIONARY", NULL, NULL, &Query_for_list_of_ts_dictionaries, NULL, THING_NO_SHOW},
1236 : {"DOMAIN", NULL, NULL, &Query_for_list_of_domains},
1237 : {"EVENT TRIGGER", NULL, NULL, NULL},
1238 : {"EXTENSION", Query_for_list_of_extensions},
1239 : {"FOREIGN DATA WRAPPER", NULL, NULL, NULL},
1240 : {"FOREIGN TABLE", NULL, NULL, NULL},
1241 : {"FUNCTION", NULL, NULL, Query_for_list_of_functions},
1242 : {"GROUP", Query_for_list_of_roles},
1243 : {"INDEX", NULL, NULL, &Query_for_list_of_indexes},
1244 : {"LANGUAGE", Query_for_list_of_languages},
1245 : {"LARGE OBJECT", NULL, NULL, NULL, NULL, THING_NO_CREATE | THING_NO_DROP},
1246 : {"MATERIALIZED VIEW", NULL, NULL, &Query_for_list_of_matviews},
1247 : {"OPERATOR", NULL, NULL, NULL}, /* Querying for this is probably not such
1248 : * a good idea. */
1249 : {"OR REPLACE", NULL, NULL, NULL, NULL, THING_NO_DROP | THING_NO_ALTER},
1250 : {"OWNED", NULL, NULL, NULL, NULL, THING_NO_CREATE | THING_NO_ALTER}, /* for DROP OWNED BY ... */
1251 : {"PARSER", NULL, NULL, &Query_for_list_of_ts_parsers, NULL, THING_NO_SHOW},
1252 : {"POLICY", NULL, NULL, NULL},
1253 : {"PROCEDURE", NULL, NULL, Query_for_list_of_procedures},
1254 : {"PUBLICATION", NULL, Query_for_list_of_publications},
1255 : {"ROLE", Query_for_list_of_roles},
1256 : {"ROUTINE", NULL, NULL, &Query_for_list_of_routines, NULL, THING_NO_CREATE},
1257 : {"RULE", "SELECT rulename FROM pg_catalog.pg_rules WHERE rulename LIKE '%s'"},
1258 : {"SCHEMA", Query_for_list_of_schemas},
1259 : {"SEQUENCE", NULL, NULL, &Query_for_list_of_sequences},
1260 : {"SERVER", Query_for_list_of_servers},
1261 : {"STATISTICS", NULL, NULL, &Query_for_list_of_statistics},
1262 : {"SUBSCRIPTION", NULL, Query_for_list_of_subscriptions},
1263 : {"SYSTEM", NULL, NULL, NULL, NULL, THING_NO_CREATE | THING_NO_DROP},
1264 : {"TABLE", NULL, NULL, &Query_for_list_of_tables},
1265 : {"TABLESPACE", Query_for_list_of_tablespaces},
1266 : {"TEMP", NULL, NULL, NULL, NULL, THING_NO_DROP | THING_NO_ALTER}, /* for CREATE TEMP TABLE
1267 : * ... */
1268 : {"TEMPLATE", NULL, NULL, &Query_for_list_of_ts_templates, NULL, THING_NO_SHOW},
1269 : {"TEMPORARY", NULL, NULL, NULL, NULL, THING_NO_DROP | THING_NO_ALTER}, /* for CREATE TEMPORARY
1270 : * TABLE ... */
1271 : {"TEXT SEARCH", NULL, NULL, NULL},
1272 : {"TRANSFORM", NULL, NULL, NULL, NULL, THING_NO_ALTER},
1273 : {"TRIGGER", "SELECT tgname FROM pg_catalog.pg_trigger WHERE tgname LIKE '%s' AND NOT tgisinternal"},
1274 : {"TYPE", NULL, NULL, &Query_for_list_of_datatypes},
1275 : {"UNIQUE", NULL, NULL, NULL, NULL, THING_NO_DROP | THING_NO_ALTER}, /* for CREATE UNIQUE
1276 : * INDEX ... */
1277 : {"UNLOGGED", NULL, NULL, NULL, NULL, THING_NO_DROP | THING_NO_ALTER}, /* for CREATE UNLOGGED
1278 : * TABLE ... */
1279 : {"USER", Query_for_list_of_roles, NULL, NULL, Keywords_for_user_thing},
1280 : {"USER MAPPING FOR", NULL, NULL, NULL},
1281 : {"VIEW", NULL, NULL, &Query_for_list_of_views},
1282 : {NULL} /* end of list */
1283 : };
1284 :
1285 : /* Storage parameters for CREATE TABLE and ALTER TABLE */
1286 : static const char *const table_storage_parameters[] = {
1287 : "autovacuum_analyze_scale_factor",
1288 : "autovacuum_analyze_threshold",
1289 : "autovacuum_enabled",
1290 : "autovacuum_freeze_max_age",
1291 : "autovacuum_freeze_min_age",
1292 : "autovacuum_freeze_table_age",
1293 : "autovacuum_multixact_freeze_max_age",
1294 : "autovacuum_multixact_freeze_min_age",
1295 : "autovacuum_multixact_freeze_table_age",
1296 : "autovacuum_vacuum_cost_delay",
1297 : "autovacuum_vacuum_cost_limit",
1298 : "autovacuum_vacuum_insert_scale_factor",
1299 : "autovacuum_vacuum_insert_threshold",
1300 : "autovacuum_vacuum_scale_factor",
1301 : "autovacuum_vacuum_threshold",
1302 : "fillfactor",
1303 : "log_autovacuum_min_duration",
1304 : "parallel_workers",
1305 : "toast.autovacuum_enabled",
1306 : "toast.autovacuum_freeze_max_age",
1307 : "toast.autovacuum_freeze_min_age",
1308 : "toast.autovacuum_freeze_table_age",
1309 : "toast.autovacuum_multixact_freeze_max_age",
1310 : "toast.autovacuum_multixact_freeze_min_age",
1311 : "toast.autovacuum_multixact_freeze_table_age",
1312 : "toast.autovacuum_vacuum_cost_delay",
1313 : "toast.autovacuum_vacuum_cost_limit",
1314 : "toast.autovacuum_vacuum_insert_scale_factor",
1315 : "toast.autovacuum_vacuum_insert_threshold",
1316 : "toast.autovacuum_vacuum_scale_factor",
1317 : "toast.autovacuum_vacuum_threshold",
1318 : "toast.log_autovacuum_min_duration",
1319 : "toast.vacuum_index_cleanup",
1320 : "toast.vacuum_truncate",
1321 : "toast_tuple_target",
1322 : "user_catalog_table",
1323 : "vacuum_index_cleanup",
1324 : "vacuum_truncate",
1325 : NULL
1326 : };
1327 :
1328 :
1329 : /* Forward declaration of functions */
1330 : static char **psql_completion(const char *text, int start, int end);
1331 : static char *create_command_generator(const char *text, int state);
1332 : static char *drop_command_generator(const char *text, int state);
1333 : static char *alter_command_generator(const char *text, int state);
1334 : static char *complete_from_query(const char *text, int state);
1335 : static char *complete_from_versioned_query(const char *text, int state);
1336 : static char *complete_from_schema_query(const char *text, int state);
1337 : static char *complete_from_versioned_schema_query(const char *text, int state);
1338 : static char *_complete_from_query(const char *simple_query,
1339 : const SchemaQuery *schema_query,
1340 : const char *const *keywords,
1341 : bool verbatim,
1342 : const char *text, int state);
1343 : static void set_completion_reference(const char *word);
1344 : static void set_completion_reference_verbatim(const char *word);
1345 : static char *complete_from_list(const char *text, int state);
1346 : static char *complete_from_const(const char *text, int state);
1347 : static void append_variable_names(char ***varnames, int *nvars,
1348 : int *maxvars, const char *varname,
1349 : const char *prefix, const char *suffix);
1350 : static char **complete_from_variables(const char *text,
1351 : const char *prefix, const char *suffix, bool need_value);
1352 : static char *complete_from_files(const char *text, int state);
1353 :
1354 : static char *pg_strdup_keyword_case(const char *s, const char *ref);
1355 : static char *escape_string(const char *text);
1356 : static char *make_like_pattern(const char *word);
1357 : static void parse_identifier(const char *ident,
1358 : char **schemaname, char **objectname,
1359 : bool *schemaquoted, bool *objectquoted);
1360 : static char *requote_identifier(const char *schemaname, const char *objectname,
1361 : bool quote_schema, bool quote_object);
1362 : static bool identifier_needs_quotes(const char *ident);
1363 : static PGresult *exec_query(const char *query);
1364 :
1365 : static char **get_previous_words(int point, char **buffer, int *nwords);
1366 :
1367 : static char *get_guctype(const char *varname);
1368 :
1369 : #ifdef USE_FILENAME_QUOTING_FUNCTIONS
1370 : static char *quote_file_name(char *fname, int match_type, char *quote_pointer);
1371 : static char *dequote_file_name(char *fname, int quote_char);
1372 : #endif
1373 :
1374 :
1375 : /*
1376 : * Initialize the readline library for our purposes.
1377 : */
1378 : void
1379 GIC 2 : initialize_readline(void)
1380 : {
1381 2 : rl_readline_name = (char *) pset.progname;
1382 2 : rl_attempted_completion_function = psql_completion;
1383 :
1384 : #ifdef USE_FILENAME_QUOTING_FUNCTIONS
1385 2 : rl_filename_quoting_function = quote_file_name;
1386 2 : rl_filename_dequoting_function = dequote_file_name;
1387 : #endif
1388 :
1389 2 : rl_basic_word_break_characters = WORD_BREAKS;
1390 :
1391 : /*
1392 : * Ideally we'd include '"' in rl_completer_quote_characters too, which
1393 : * should allow us to complete quoted identifiers that include spaces.
1394 : * However, the library support for rl_completer_quote_characters is
1395 : * presently too inconsistent to want to mess with that. (Note in
1396 : * particular that libedit has this variable but completely ignores it.)
1397 : */
1398 2 : rl_completer_quote_characters = "'";
1399 :
1400 ECB : /*
1401 : * Set rl_filename_quote_characters to "all possible characters",
1402 : * otherwise Readline will skip filename quoting if it thinks a filename
1403 : * doesn't need quoting. Readline actually interprets this as bytes, so
1404 : * there are no encoding considerations here.
1405 : */
1406 : #ifdef HAVE_RL_FILENAME_QUOTE_CHARACTERS
1407 : {
1408 GIC 2 : unsigned char *fqc = (unsigned char *) pg_malloc(256);
1409 :
1410 CBC 512 : for (int i = 0; i < 255; i++)
1411 GIC 510 : fqc[i] = (unsigned char) (i + 1);
1412 2 : fqc[255] = '\0';
1413 2 : rl_filename_quote_characters = (const char *) fqc;
1414 : }
1415 : #endif
1416 :
1417 2 : completion_max_records = 1000;
1418 :
1419 ECB : /*
1420 : * There is a variable rl_completion_query_items for this but apparently
1421 : * it's not defined everywhere.
1422 : */
1423 GIC 2 : }
1424 :
1425 : /*
1426 : * Check if 'word' matches any of the '|'-separated strings in 'pattern',
1427 : * using case-insensitive or case-sensitive comparisons.
1428 : *
1429 ECB : * If pattern is NULL, it's a wild card that matches any word.
1430 : * If pattern begins with '!', the result is negated, ie we check that 'word'
1431 : * does *not* match any alternative appearing in the rest of 'pattern'.
1432 : * Any alternative can contain '*' which is a wild card, i.e., it can match
1433 : * any substring; however, we allow at most one '*' per alternative.
1434 : *
1435 : * For readability, callers should use the macros MatchAny and MatchAnyExcept
1436 : * to invoke those two special cases for 'pattern'. (But '|' and '*' must
1437 : * just be written directly in patterns.)
1438 : */
1439 : #define MatchAny NULL
1440 : #define MatchAnyExcept(pattern) ("!" pattern)
1441 :
1442 : static bool
1443 GIC 8924 : word_matches(const char *pattern,
1444 ECB : const char *word,
1445 : bool case_sensitive)
1446 : {
1447 : size_t wordlen;
1448 :
1449 : #define cimatch(s1, s2, n) \
1450 : (case_sensitive ? strncmp(s1, s2, n) == 0 : pg_strncasecmp(s1, s2, n) == 0)
1451 :
1452 : /* NULL pattern matches anything. */
1453 GIC 8924 : if (pattern == NULL)
1454 160 : return true;
1455 :
1456 : /* Handle negated patterns from the MatchAnyExcept macro. */
1457 8764 : if (*pattern == '!')
1458 UIC 0 : return !word_matches(pattern + 1, word, case_sensitive);
1459 :
1460 : /* Else consider each alternative in the pattern. */
1461 GIC 8764 : wordlen = strlen(word);
1462 : for (;;)
1463 764 : {
1464 CBC 9528 : const char *star = NULL;
1465 : const char *c;
1466 :
1467 : /* Find end of current alternative, and locate any wild card. */
1468 GIC 9528 : c = pattern;
1469 64171 : while (*c != '\0' && *c != '|')
1470 : {
1471 54643 : if (*c == '*')
1472 397 : star = c;
1473 54643 : c++;
1474 ECB : }
1475 : /* Was there a wild card? */
1476 GIC 9528 : if (star)
1477 : {
1478 ECB : /* Yes, wildcard match? */
1479 GBC 397 : size_t beforelen = star - pattern,
1480 GIC 397 : afterlen = c - star - 1;
1481 :
1482 CBC 786 : if (wordlen >= (beforelen + afterlen) &&
1483 GIC 401 : cimatch(word, pattern, beforelen) &&
1484 CBC 6 : cimatch(word + wordlen - afterlen, star + 1, afterlen))
1485 6 : return true;
1486 : }
1487 : else
1488 : {
1489 ECB : /* No, plain match? */
1490 CBC 11593 : if (wordlen == (c - pattern) &&
1491 GIC 2462 : cimatch(word, pattern, wordlen))
1492 CBC 1277 : return true;
1493 ECB : }
1494 : /* Out of alternatives? */
1495 GIC 8245 : if (*c == '\0')
1496 7481 : break;
1497 ECB : /* Nope, try next alternative. */
1498 GIC 764 : pattern = c + 1;
1499 : }
1500 ECB :
1501 CBC 7481 : return false;
1502 : }
1503 ECB :
1504 : /*
1505 : * Implementation of TailMatches and TailMatchesCS macros: do the last N words
1506 : * in previous_words match the variadic arguments?
1507 : *
1508 : * The array indexing might look backwards, but remember that
1509 : * previous_words[0] contains the *last* word on the line, not the first.
1510 : */
1511 : static bool
1512 CBC 6537 : TailMatchesImpl(bool case_sensitive,
1513 ECB : int previous_words_count, char **previous_words,
1514 : int narg,...)
1515 : {
1516 : va_list args;
1517 :
1518 GIC 6537 : if (previous_words_count < narg)
1519 CBC 4437 : return false;
1520 :
1521 GIC 2100 : va_start(args, narg);
1522 ECB :
1523 GIC 2183 : for (int argno = 0; argno < narg; argno++)
1524 : {
1525 2150 : const char *arg = va_arg(args, const char *);
1526 :
1527 2150 : if (!word_matches(arg, previous_words[narg - argno - 1],
1528 : case_sensitive))
1529 : {
1530 2067 : va_end(args);
1531 2067 : return false;
1532 : }
1533 ECB : }
1534 :
1535 GIC 33 : va_end(args);
1536 :
1537 33 : return true;
1538 : }
1539 ECB :
1540 : /*
1541 : * Implementation of Matches and MatchesCS macros: do all of the words
1542 : * in previous_words match the variadic arguments?
1543 : */
1544 : static bool
1545 GIC 21442 : MatchesImpl(bool case_sensitive,
1546 ECB : int previous_words_count, char **previous_words,
1547 : int narg,...)
1548 : {
1549 : va_list args;
1550 :
1551 CBC 21442 : if (previous_words_count != narg)
1552 18095 : return false;
1553 :
1554 GIC 3347 : va_start(args, narg);
1555 :
1556 CBC 4469 : for (int argno = 0; argno < narg; argno++)
1557 : {
1558 4441 : const char *arg = va_arg(args, const char *);
1559 :
1560 GIC 4441 : if (!word_matches(arg, previous_words[narg - argno - 1],
1561 : case_sensitive))
1562 : {
1563 3319 : va_end(args);
1564 3319 : return false;
1565 : }
1566 ECB : }
1567 :
1568 GIC 28 : va_end(args);
1569 :
1570 28 : return true;
1571 : }
1572 ECB :
1573 : /*
1574 : * Implementation of HeadMatches and HeadMatchesCS macros: do the first N
1575 : * words in previous_words match the variadic arguments?
1576 : */
1577 : static bool
1578 GIC 3294 : HeadMatchesImpl(bool case_sensitive,
1579 ECB : int previous_words_count, char **previous_words,
1580 : int narg,...)
1581 : {
1582 : va_list args;
1583 :
1584 CBC 3294 : if (previous_words_count < narg)
1585 1197 : return false;
1586 :
1587 GIC 2097 : va_start(args, narg);
1588 :
1589 CBC 2335 : for (int argno = 0; argno < narg; argno++)
1590 : {
1591 2333 : const char *arg = va_arg(args, const char *);
1592 :
1593 GIC 2333 : if (!word_matches(arg, previous_words[previous_words_count - argno - 1],
1594 : case_sensitive))
1595 : {
1596 2095 : va_end(args);
1597 2095 : return false;
1598 : }
1599 ECB : }
1600 :
1601 GIC 2 : va_end(args);
1602 :
1603 2 : return true;
1604 : }
1605 ECB :
1606 : /*
1607 : * Check if the final character of 's' is 'c'.
1608 : */
1609 : static bool
1610 CBC 2 : ends_with(const char *s, char c)
1611 : {
1612 2 : size_t length = strlen(s);
1613 :
1614 2 : return (length > 0 && s[length - 1] == c);
1615 : }
1616 :
1617 ECB : /*
1618 : * The completion function.
1619 : *
1620 : * According to readline spec this gets passed the text entered so far and its
1621 : * start and end positions in the readline buffer. The return value is some
1622 : * partially obscure list format that can be generated by readline's
1623 : * rl_completion_matches() function, so we don't have to worry about it.
1624 : */
1625 : static char **
1626 GIC 66 : psql_completion(const char *text, int start, int end)
1627 : {
1628 : /* This is the variable we'll return. */
1629 66 : char **matches = NULL;
1630 :
1631 ECB : /* Workspace for parsed words. */
1632 : char *words_buffer;
1633 :
1634 : /* This array will contain pointers to parsed words. */
1635 : char **previous_words;
1636 :
1637 : /* The number of words found on the input line. */
1638 : int previous_words_count;
1639 :
1640 : /*
1641 : * For compactness, we use these macros to reference previous_words[].
1642 : * Caution: do not access a previous_words[] entry without having checked
1643 : * previous_words_count to be sure it's valid. In most cases below, that
1644 : * check is implicit in a TailMatches() or similar macro, but in some
1645 : * places we have to check it explicitly.
1646 : */
1647 : #define prev_wd (previous_words[0])
1648 : #define prev2_wd (previous_words[1])
1649 : #define prev3_wd (previous_words[2])
1650 : #define prev4_wd (previous_words[3])
1651 : #define prev5_wd (previous_words[4])
1652 : #define prev6_wd (previous_words[5])
1653 : #define prev7_wd (previous_words[6])
1654 : #define prev8_wd (previous_words[7])
1655 : #define prev9_wd (previous_words[8])
1656 :
1657 : /* Match the last N words before point, case-insensitively. */
1658 : #define TailMatches(...) \
1659 : TailMatchesImpl(false, previous_words_count, previous_words, \
1660 : VA_ARGS_NARGS(__VA_ARGS__), __VA_ARGS__)
1661 :
1662 : /* Match the last N words before point, case-sensitively. */
1663 : #define TailMatchesCS(...) \
1664 : TailMatchesImpl(true, previous_words_count, previous_words, \
1665 : VA_ARGS_NARGS(__VA_ARGS__), __VA_ARGS__)
1666 :
1667 : /* Match N words representing all of the line, case-insensitively. */
1668 : #define Matches(...) \
1669 : MatchesImpl(false, previous_words_count, previous_words, \
1670 : VA_ARGS_NARGS(__VA_ARGS__), __VA_ARGS__)
1671 :
1672 : /* Match N words representing all of the line, case-sensitively. */
1673 : #define MatchesCS(...) \
1674 : MatchesImpl(true, previous_words_count, previous_words, \
1675 : VA_ARGS_NARGS(__VA_ARGS__), __VA_ARGS__)
1676 :
1677 : /* Match the first N words on the line, case-insensitively. */
1678 : #define HeadMatches(...) \
1679 : HeadMatchesImpl(false, previous_words_count, previous_words, \
1680 : VA_ARGS_NARGS(__VA_ARGS__), __VA_ARGS__)
1681 :
1682 : /* Match the first N words on the line, case-sensitively. */
1683 : #define HeadMatchesCS(...) \
1684 : HeadMatchesImpl(true, previous_words_count, previous_words, \
1685 : VA_ARGS_NARGS(__VA_ARGS__), __VA_ARGS__)
1686 :
1687 : /* Known command-starting keywords. */
1688 : static const char *const sql_commands[] = {
1689 : "ABORT", "ALTER", "ANALYZE", "BEGIN", "CALL", "CHECKPOINT", "CLOSE", "CLUSTER",
1690 : "COMMENT", "COMMIT", "COPY", "CREATE", "DEALLOCATE", "DECLARE",
1691 : "DELETE FROM", "DISCARD", "DO", "DROP", "END", "EXECUTE", "EXPLAIN",
1692 : "FETCH", "GRANT", "IMPORT FOREIGN SCHEMA", "INSERT INTO", "LISTEN", "LOAD", "LOCK",
1693 : "MERGE INTO", "MOVE", "NOTIFY", "PREPARE",
1694 : "REASSIGN", "REFRESH MATERIALIZED VIEW", "REINDEX", "RELEASE",
1695 : "RESET", "REVOKE", "ROLLBACK",
1696 : "SAVEPOINT", "SECURITY LABEL", "SELECT", "SET", "SHOW", "START",
1697 : "TABLE", "TRUNCATE", "UNLISTEN", "UPDATE", "VACUUM", "VALUES", "WITH",
1698 : NULL
1699 : };
1700 :
1701 : /* psql's backslash commands. */
1702 : static const char *const backslash_commands[] = {
1703 : "\\a",
1704 : "\\bind",
1705 : "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy",
1706 : "\\copyright", "\\crosstabview",
1707 : "\\d", "\\da", "\\dA", "\\dAc", "\\dAf", "\\dAo", "\\dAp",
1708 : "\\db", "\\dc", "\\dconfig", "\\dC", "\\dd", "\\ddp", "\\dD",
1709 : "\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
1710 : "\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
1711 : "\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\dP", "\\dPi", "\\dPt",
1712 : "\\drds", "\\dRs", "\\dRp", "\\ds",
1713 : "\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dX", "\\dy",
1714 : "\\echo", "\\edit", "\\ef", "\\elif", "\\else", "\\encoding",
1715 : "\\endif", "\\errverbose", "\\ev",
1716 : "\\f",
1717 : "\\g", "\\gdesc", "\\getenv", "\\gexec", "\\gset", "\\gx",
1718 : "\\help", "\\html",
1719 : "\\if", "\\include", "\\include_relative", "\\ir",
1720 : "\\list", "\\lo_import", "\\lo_export", "\\lo_list", "\\lo_unlink",
1721 : "\\out",
1722 : "\\password", "\\print", "\\prompt", "\\pset",
1723 : "\\qecho", "\\quit",
1724 : "\\reset",
1725 : "\\s", "\\set", "\\setenv", "\\sf", "\\sv",
1726 : "\\t", "\\T", "\\timing",
1727 : "\\unset",
1728 : "\\x",
1729 : "\\warn", "\\watch", "\\write",
1730 : "\\z",
1731 : "\\!", "\\?",
1732 : NULL
1733 : };
1734 :
1735 : /*
1736 : * Temporary workaround for a bug in recent (2019) libedit: it incorrectly
1737 : * de-escapes the input "text", causing us to fail to recognize backslash
1738 : * commands. So get the string to look at from rl_line_buffer instead.
1739 : */
1740 GIC 66 : char *text_copy = pnstrdup(rl_line_buffer + start, end - start);
1741 66 : text = text_copy;
1742 :
1743 : /* Remember last char of the given input word. */
1744 66 : completion_last_char = (end > start) ? text[end - start - 1] : '\0';
1745 :
1746 : /* We usually want the append character to be a space. */
1747 66 : rl_completion_append_character = ' ';
1748 :
1749 : /* Clear a few things. */
1750 66 : completion_charp = NULL;
1751 66 : completion_charpp = NULL;
1752 66 : completion_vquery = NULL;
1753 66 : completion_squery = NULL;
1754 66 : completion_ref_object = NULL;
1755 66 : completion_ref_schema = NULL;
1756 :
1757 : /*
1758 : * Scan the input line to extract the words before our current position.
1759 : * According to those we'll make some smart decisions on what the user is
1760 : * probably intending to type.
1761 : */
1762 CBC 66 : previous_words = get_previous_words(start,
1763 ECB : &words_buffer,
1764 : &previous_words_count);
1765 :
1766 : /* If current word is a backslash command, offer completions for that */
1767 GIC 66 : if (text[0] == '\\')
1768 1 : COMPLETE_WITH_LIST_CS(backslash_commands);
1769 ECB :
1770 : /* If current word is a variable interpolation, handle that case */
1771 GIC 65 : else if (text[0] == ':' && text[1] != ':')
1772 ECB : {
1773 CBC 1 : if (text[1] == '\'')
1774 LBC 0 : matches = complete_from_variables(text, ":'", "'", true);
1775 CBC 1 : else if (text[1] == '"')
1776 LBC 0 : matches = complete_from_variables(text, ":\"", "\"", true);
1777 ECB : else
1778 GIC 1 : matches = complete_from_variables(text, ":", "", true);
1779 : }
1780 :
1781 : /* If no previous word, suggest one of the basic sql commands */
1782 64 : else if (previous_words_count == 0)
1783 2 : COMPLETE_WITH_LIST(sql_commands);
1784 ECB :
1785 : /* CREATE */
1786 : /* complete with something you can create */
1787 GIC 62 : else if (TailMatches("CREATE"))
1788 1 : matches = rl_completion_matches(text, create_command_generator);
1789 ECB :
1790 : /* complete with something you can create or replace */
1791 GIC 61 : else if (TailMatches("CREATE", "OR", "REPLACE"))
1792 UIC 0 : COMPLETE_WITH("FUNCTION", "PROCEDURE", "LANGUAGE", "RULE", "VIEW",
1793 ECB : "AGGREGATE", "TRANSFORM", "TRIGGER");
1794 :
1795 : /* DROP, but not DROP embedded in other commands */
1796 EUB : /* complete with something you can drop */
1797 CBC 61 : else if (Matches("DROP"))
1798 GBC 1 : matches = rl_completion_matches(text, drop_command_generator);
1799 :
1800 ECB : /* ALTER */
1801 :
1802 : /* ALTER TABLE */
1803 GIC 60 : else if (Matches("ALTER", "TABLE"))
1804 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables,
1805 ECB : "ALL IN TABLESPACE");
1806 :
1807 : /* ALTER something */
1808 GIC 60 : else if (Matches("ALTER"))
1809 LBC 0 : matches = rl_completion_matches(text, alter_command_generator);
1810 ECB : /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx */
1811 GIC 60 : else if (TailMatches("ALL", "IN", "TABLESPACE", MatchAny))
1812 UIC 0 : COMPLETE_WITH("SET TABLESPACE", "OWNED BY");
1813 ECB : /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx OWNED BY */
1814 GBC 60 : else if (TailMatches("ALL", "IN", "TABLESPACE", MatchAny, "OWNED", "BY"))
1815 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
1816 : /* ALTER TABLE,INDEX,MATERIALIZED VIEW ALL IN TABLESPACE xxx OWNED BY xxx */
1817 GIC 60 : else if (TailMatches("ALL", "IN", "TABLESPACE", MatchAny, "OWNED", "BY", MatchAny))
1818 UIC 0 : COMPLETE_WITH("SET TABLESPACE");
1819 ECB : /* ALTER AGGREGATE,FUNCTION,PROCEDURE,ROUTINE <name> */
1820 CBC 60 : else if (Matches("ALTER", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny))
1821 UIC 0 : COMPLETE_WITH("(");
1822 : /* ALTER AGGREGATE <name> (...) */
1823 GIC 60 : else if (Matches("ALTER", "AGGREGATE", MatchAny, MatchAny))
1824 : {
1825 LBC 0 : if (ends_with(prev_wd, ')'))
1826 UBC 0 : COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA");
1827 : else
1828 UIC 0 : COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
1829 : }
1830 : /* ALTER FUNCTION <name> (...) */
1831 GNC 60 : else if (Matches("ALTER", "FUNCTION", MatchAny, MatchAny))
1832 : {
1833 LBC 0 : if (ends_with(prev_wd, ')'))
1834 UNC 0 : COMPLETE_WITH(Alter_function_options);
1835 ECB : else
1836 UBC 0 : COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
1837 : }
1838 : /* ALTER PROCEDURE <name> (...) */
1839 GNC 60 : else if (Matches("ALTER", "PROCEDURE", MatchAny, MatchAny))
1840 : {
1841 UNC 0 : if (ends_with(prev_wd, ')'))
1842 0 : COMPLETE_WITH(Alter_procedure_options);
1843 : else
1844 0 : COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
1845 : }
1846 : /* ALTER ROUTINE <name> (...) */
1847 GNC 60 : else if (Matches("ALTER", "ROUTINE", MatchAny, MatchAny))
1848 : {
1849 UNC 0 : if (ends_with(prev_wd, ')'))
1850 0 : COMPLETE_WITH(Alter_routine_options);
1851 : else
1852 0 : COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
1853 : }
1854 : /* ALTER FUNCTION|ROUTINE <name> (...) PARALLEL */
1855 GNC 60 : else if (Matches("ALTER", "FUNCTION|ROUTINE", MatchAny, MatchAny, "PARALLEL"))
1856 UNC 0 : COMPLETE_WITH("RESTRICTED", "SAFE", "UNSAFE");
1857 : /* ALTER FUNCTION|PROCEDURE|ROUTINE <name> (...) [EXTERNAL] SECURITY */
1858 GNC 120 : else if (Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "SECURITY") ||
1859 60 : Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "EXTERNAL", "SECURITY"))
1860 UNC 0 : COMPLETE_WITH("DEFINER", "INVOKER");
1861 : /* ALTER FUNCTION|PROCEDURE|ROUTINE <name> (...) RESET */
1862 GNC 60 : else if (Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "RESET"))
1863 UNC 0 : COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars,
1864 : "ALL");
1865 : /* ALTER FUNCTION|PROCEDURE|ROUTINE <name> (...) SET */
1866 GNC 60 : else if (Matches("ALTER", "FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny, "SET"))
1867 UNC 0 : COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars,
1868 : "SCHEMA");
1869 ECB :
1870 EUB : /* ALTER PUBLICATION <name> */
1871 GIC 60 : else if (Matches("ALTER", "PUBLICATION", MatchAny))
1872 LBC 0 : COMPLETE_WITH("ADD", "DROP", "OWNER TO", "RENAME TO", "SET");
1873 EUB : /* ALTER PUBLICATION <name> ADD */
1874 GIC 60 : else if (Matches("ALTER", "PUBLICATION", MatchAny, "ADD"))
1875 LBC 0 : COMPLETE_WITH("TABLES IN SCHEMA", "TABLE");
1876 GIC 120 : else if (Matches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE") ||
1877 GBC 60 : (HeadMatches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE") &&
1878 UBC 0 : ends_with(prev_wd, ',')))
1879 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
1880 EUB :
1881 : /*
1882 : * "ALTER PUBLICATION <name> SET TABLE <name> WHERE (" - complete with
1883 ECB : * table attributes
1884 : *
1885 EUB : * "ALTER PUBLICATION <name> ADD TABLE <name> WHERE (" - complete with
1886 : * table attributes
1887 : */
1888 GBC 60 : else if (HeadMatches("ALTER", "PUBLICATION", MatchAny) && TailMatches("WHERE"))
1889 UIC 0 : COMPLETE_WITH("(");
1890 GIC 60 : else if (HeadMatches("ALTER", "PUBLICATION", MatchAny) && TailMatches("WHERE", "("))
1891 LBC 0 : COMPLETE_WITH_ATTR(prev3_wd);
1892 GIC 60 : else if (HeadMatches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE") &&
1893 UBC 0 : !TailMatches("WHERE", "(*)"))
1894 0 : COMPLETE_WITH(",", "WHERE (");
1895 GIC 60 : else if (HeadMatches("ALTER", "PUBLICATION", MatchAny, "ADD|SET", "TABLE"))
1896 UBC 0 : COMPLETE_WITH(",");
1897 : /* ALTER PUBLICATION <name> DROP */
1898 GIC 60 : else if (Matches("ALTER", "PUBLICATION", MatchAny, "DROP"))
1899 LBC 0 : COMPLETE_WITH("TABLES IN SCHEMA", "TABLE");
1900 : /* ALTER PUBLICATION <name> SET */
1901 GBC 60 : else if (Matches("ALTER", "PUBLICATION", MatchAny, "SET"))
1902 UBC 0 : COMPLETE_WITH("(", "TABLES IN SCHEMA", "TABLE");
1903 GIC 60 : else if (Matches("ALTER", "PUBLICATION", MatchAny, "ADD|DROP|SET", "TABLES", "IN", "SCHEMA"))
1904 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas
1905 : " AND nspname NOT LIKE E'pg\\\\_%%'",
1906 : "CURRENT_SCHEMA");
1907 ECB : /* ALTER PUBLICATION <name> SET ( */
1908 GBC 60 : else if (HeadMatches("ALTER", "PUBLICATION", MatchAny) && TailMatches("SET", "("))
1909 UIC 0 : COMPLETE_WITH("publish", "publish_via_partition_root");
1910 ECB : /* ALTER SUBSCRIPTION <name> */
1911 CBC 60 : else if (Matches("ALTER", "SUBSCRIPTION", MatchAny))
1912 UBC 0 : COMPLETE_WITH("CONNECTION", "ENABLE", "DISABLE", "OWNER TO",
1913 : "RENAME TO", "REFRESH PUBLICATION", "SET", "SKIP (",
1914 ECB : "ADD PUBLICATION", "DROP PUBLICATION");
1915 EUB : /* ALTER SUBSCRIPTION <name> REFRESH PUBLICATION */
1916 GIC 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) &&
1917 UIC 0 : TailMatches("REFRESH", "PUBLICATION"))
1918 LBC 0 : COMPLETE_WITH("WITH (");
1919 EUB : /* ALTER SUBSCRIPTION <name> REFRESH PUBLICATION WITH ( */
1920 GIC 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) &&
1921 UIC 0 : TailMatches("REFRESH", "PUBLICATION", "WITH", "("))
1922 0 : COMPLETE_WITH("copy_data");
1923 ECB : /* ALTER SUBSCRIPTION <name> SET */
1924 GBC 60 : else if (Matches("ALTER", "SUBSCRIPTION", MatchAny, "SET"))
1925 UIC 0 : COMPLETE_WITH("(", "PUBLICATION");
1926 ECB : /* ALTER SUBSCRIPTION <name> SET ( */
1927 GBC 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) && TailMatches("SET", "("))
1928 UNC 0 : COMPLETE_WITH("binary", "disable_on_error", "origin",
1929 : "password_required", "run_as_owner", "slot_name",
1930 : "streaming", "synchronous_commit");
1931 ECB : /* ALTER SUBSCRIPTION <name> SKIP ( */
1932 GBC 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) && TailMatches("SKIP", "("))
1933 UBC 0 : COMPLETE_WITH("lsn");
1934 : /* ALTER SUBSCRIPTION <name> SET PUBLICATION */
1935 GIC 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) && TailMatches("SET", "PUBLICATION"))
1936 : {
1937 : /* complete with nothing here as this refers to remote publications */
1938 : }
1939 : /* ALTER SUBSCRIPTION <name> ADD|DROP|SET PUBLICATION <name> */
1940 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) &&
1941 UIC 0 : TailMatches("ADD|DROP|SET", "PUBLICATION", MatchAny))
1942 LBC 0 : COMPLETE_WITH("WITH (");
1943 EUB : /* ALTER SUBSCRIPTION <name> ADD|DROP|SET PUBLICATION <name> WITH ( */
1944 CBC 60 : else if (HeadMatches("ALTER", "SUBSCRIPTION", MatchAny) &&
1945 UBC 0 : TailMatches("ADD|DROP|SET", "PUBLICATION", MatchAny, "WITH", "("))
1946 LBC 0 : COMPLETE_WITH("copy_data", "refresh");
1947 EUB :
1948 : /* ALTER SCHEMA <name> */
1949 CBC 60 : else if (Matches("ALTER", "SCHEMA", MatchAny))
1950 UBC 0 : COMPLETE_WITH("OWNER TO", "RENAME TO");
1951 :
1952 ECB : /* ALTER COLLATION <name> */
1953 GBC 60 : else if (Matches("ALTER", "COLLATION", MatchAny))
1954 UIC 0 : COMPLETE_WITH("OWNER TO", "REFRESH VERSION", "RENAME TO", "SET SCHEMA");
1955 ECB :
1956 EUB : /* ALTER CONVERSION <name> */
1957 CBC 60 : else if (Matches("ALTER", "CONVERSION", MatchAny))
1958 UBC 0 : COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA");
1959 :
1960 : /* ALTER DATABASE <name> */
1961 GIC 60 : else if (Matches("ALTER", "DATABASE", MatchAny))
1962 LBC 0 : COMPLETE_WITH("RESET", "SET", "OWNER TO", "REFRESH COLLATION VERSION", "RENAME TO",
1963 EUB : "IS_TEMPLATE", "ALLOW_CONNECTIONS",
1964 : "CONNECTION LIMIT");
1965 ECB :
1966 EUB : /* ALTER DATABASE <name> SET TABLESPACE */
1967 GIC 60 : else if (Matches("ALTER", "DATABASE", MatchAny, "SET", "TABLESPACE"))
1968 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
1969 :
1970 ECB : /* ALTER EVENT TRIGGER */
1971 GBC 60 : else if (Matches("ALTER", "EVENT", "TRIGGER"))
1972 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
1973 :
1974 ECB : /* ALTER EVENT TRIGGER <name> */
1975 GBC 60 : else if (Matches("ALTER", "EVENT", "TRIGGER", MatchAny))
1976 UBC 0 : COMPLETE_WITH("DISABLE", "ENABLE", "OWNER TO", "RENAME TO");
1977 :
1978 ECB : /* ALTER EVENT TRIGGER <name> ENABLE */
1979 GBC 60 : else if (Matches("ALTER", "EVENT", "TRIGGER", MatchAny, "ENABLE"))
1980 UIC 0 : COMPLETE_WITH("REPLICA", "ALWAYS");
1981 ECB :
1982 EUB : /* ALTER EXTENSION <name> */
1983 GIC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny))
1984 UIC 0 : COMPLETE_WITH("ADD", "DROP", "UPDATE", "SET SCHEMA");
1985 :
1986 : /* ALTER EXTENSION <name> ADD|DROP */
1987 GNC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP"))
1988 UNC 0 : COMPLETE_WITH("ACCESS METHOD", "AGGREGATE", "CAST", "COLLATION",
1989 : "CONVERSION", "DOMAIN", "EVENT TRIGGER", "FOREIGN",
1990 : "FUNCTION", "MATERIALIZED VIEW", "OPERATOR",
1991 : "LANGUAGE", "PROCEDURE", "ROUTINE", "SCHEMA",
1992 : "SEQUENCE", "SERVER", "TABLE", "TEXT SEARCH",
1993 : "TRANSFORM FOR", "TYPE", "VIEW");
1994 :
1995 : /* ALTER EXTENSION <name> ADD|DROP FOREIGN */
1996 GNC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP", "FOREIGN"))
1997 UNC 0 : COMPLETE_WITH("DATA WRAPPER", "TABLE");
1998 :
1999 : /* ALTER EXTENSION <name> ADD|DROP OPERATOR */
2000 GNC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP", "OPERATOR"))
2001 UNC 0 : COMPLETE_WITH("CLASS", "FAMILY");
2002 :
2003 : /* ALTER EXTENSION <name> ADD|DROP TEXT SEARCH */
2004 GNC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny, "ADD|DROP", "TEXT", "SEARCH"))
2005 UNC 0 : COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE");
2006 :
2007 ECB : /* ALTER EXTENSION <name> UPDATE */
2008 GBC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny, "UPDATE"))
2009 UIC 0 : COMPLETE_WITH("TO");
2010 ECB :
2011 : /* ALTER EXTENSION <name> UPDATE TO */
2012 GIC 60 : else if (Matches("ALTER", "EXTENSION", MatchAny, "UPDATE", "TO"))
2013 : {
2014 UIC 0 : set_completion_reference(prev3_wd);
2015 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions);
2016 EUB : }
2017 :
2018 : /* ALTER FOREIGN */
2019 CBC 60 : else if (Matches("ALTER", "FOREIGN"))
2020 UBC 0 : COMPLETE_WITH("DATA WRAPPER", "TABLE");
2021 EUB :
2022 : /* ALTER FOREIGN DATA WRAPPER <name> */
2023 GIC 60 : else if (Matches("ALTER", "FOREIGN", "DATA", "WRAPPER", MatchAny))
2024 LBC 0 : COMPLETE_WITH("HANDLER", "VALIDATOR", "NO",
2025 EUB : "OPTIONS", "OWNER TO", "RENAME TO");
2026 GIC 60 : else if (Matches("ALTER", "FOREIGN", "DATA", "WRAPPER", MatchAny, "NO"))
2027 UIC 0 : COMPLETE_WITH("HANDLER", "VALIDATOR");
2028 ECB :
2029 EUB : /* ALTER FOREIGN TABLE <name> */
2030 GIC 60 : else if (Matches("ALTER", "FOREIGN", "TABLE", MatchAny))
2031 UIC 0 : COMPLETE_WITH("ADD", "ALTER", "DISABLE TRIGGER", "DROP", "ENABLE",
2032 ECB : "INHERIT", "NO INHERIT", "OPTIONS", "OWNER TO",
2033 EUB : "RENAME", "SET", "VALIDATE CONSTRAINT");
2034 :
2035 : /* ALTER INDEX */
2036 CBC 60 : else if (Matches("ALTER", "INDEX"))
2037 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes,
2038 : "ALL IN TABLESPACE");
2039 : /* ALTER INDEX <name> */
2040 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny))
2041 UIC 0 : COMPLETE_WITH("ALTER COLUMN", "OWNER TO", "RENAME TO", "SET",
2042 ECB : "RESET", "ATTACH PARTITION",
2043 EUB : "DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION");
2044 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ATTACH"))
2045 UIC 0 : COMPLETE_WITH("PARTITION");
2046 CBC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ATTACH", "PARTITION"))
2047 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes);
2048 : /* ALTER INDEX <name> ALTER */
2049 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ALTER"))
2050 LBC 0 : COMPLETE_WITH("COLUMN");
2051 EUB : /* ALTER INDEX <name> ALTER COLUMN */
2052 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN"))
2053 : {
2054 LBC 0 : set_completion_reference(prev3_wd);
2055 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY_VERBATIM(Query_for_list_of_attribute_numbers);
2056 : }
2057 : /* ALTER INDEX <name> ALTER COLUMN <colnum> */
2058 CBC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN", MatchAny))
2059 UBC 0 : COMPLETE_WITH("SET STATISTICS");
2060 : /* ALTER INDEX <name> ALTER COLUMN <colnum> SET */
2061 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN", MatchAny, "SET"))
2062 LBC 0 : COMPLETE_WITH("STATISTICS");
2063 EUB : /* ALTER INDEX <name> ALTER COLUMN <colnum> SET STATISTICS */
2064 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "STATISTICS"))
2065 : {
2066 : /* Enforce no completion here, as an integer has to be specified */
2067 : }
2068 : /* ALTER INDEX <name> SET */
2069 60 : else if (Matches("ALTER", "INDEX", MatchAny, "SET"))
2070 UIC 0 : COMPLETE_WITH("(", "TABLESPACE");
2071 ECB : /* ALTER INDEX <name> RESET */
2072 GBC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "RESET"))
2073 UIC 0 : COMPLETE_WITH("(");
2074 : /* ALTER INDEX <foo> SET|RESET ( */
2075 CBC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "RESET", "("))
2076 UBC 0 : COMPLETE_WITH("fillfactor",
2077 : "deduplicate_items", /* BTREE */
2078 : "fastupdate", "gin_pending_list_limit", /* GIN */
2079 ECB : "buffering", /* GiST */
2080 EUB : "pages_per_range", "autosummarize" /* BRIN */
2081 : );
2082 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "SET", "("))
2083 LBC 0 : COMPLETE_WITH("fillfactor =",
2084 EUB : "deduplicate_items =", /* BTREE */
2085 : "fastupdate =", "gin_pending_list_limit =", /* GIN */
2086 : "buffering =", /* GiST */
2087 ECB : "pages_per_range =", "autosummarize =" /* BRIN */
2088 : );
2089 GBC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "NO", "DEPENDS"))
2090 UBC 0 : COMPLETE_WITH("ON EXTENSION");
2091 GIC 60 : else if (Matches("ALTER", "INDEX", MatchAny, "DEPENDS"))
2092 UIC 0 : COMPLETE_WITH("ON EXTENSION");
2093 :
2094 ECB : /* ALTER LANGUAGE <name> */
2095 GBC 60 : else if (Matches("ALTER", "LANGUAGE", MatchAny))
2096 UIC 0 : COMPLETE_WITH("OWNER TO", "RENAME TO");
2097 :
2098 ECB : /* ALTER LARGE OBJECT <oid> */
2099 GBC 60 : else if (Matches("ALTER", "LARGE", "OBJECT", MatchAny))
2100 UIC 0 : COMPLETE_WITH("OWNER TO");
2101 ECB :
2102 EUB : /* ALTER MATERIALIZED VIEW */
2103 GIC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW"))
2104 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_matviews,
2105 ECB : "ALL IN TABLESPACE");
2106 EUB :
2107 : /* ALTER USER,ROLE <name> */
2108 GIC 60 : else if (Matches("ALTER", "USER|ROLE", MatchAny) &&
2109 UIC 0 : !TailMatches("USER", "MAPPING"))
2110 0 : COMPLETE_WITH("BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE",
2111 ECB : "ENCRYPTED PASSWORD", "INHERIT", "LOGIN", "NOBYPASSRLS",
2112 EUB : "NOCREATEDB", "NOCREATEROLE", "NOINHERIT",
2113 : "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD",
2114 : "RENAME TO", "REPLICATION", "RESET", "SET", "SUPERUSER",
2115 ECB : "VALID UNTIL", "WITH");
2116 EUB :
2117 : /* ALTER USER,ROLE <name> WITH */
2118 GIC 60 : else if (Matches("ALTER", "USER|ROLE", MatchAny, "WITH"))
2119 ECB : /* Similar to the above, but don't complete "WITH" again. */
2120 UBC 0 : COMPLETE_WITH("BYPASSRLS", "CONNECTION LIMIT", "CREATEDB", "CREATEROLE",
2121 ECB : "ENCRYPTED PASSWORD", "INHERIT", "LOGIN", "NOBYPASSRLS",
2122 EUB : "NOCREATEDB", "NOCREATEROLE", "NOINHERIT",
2123 : "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD",
2124 ECB : "RENAME TO", "REPLICATION", "RESET", "SET", "SUPERUSER",
2125 EUB : "VALID UNTIL");
2126 :
2127 ECB : /* ALTER DEFAULT PRIVILEGES */
2128 GIC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES"))
2129 UBC 0 : COMPLETE_WITH("FOR ROLE", "IN SCHEMA");
2130 EUB : /* ALTER DEFAULT PRIVILEGES FOR */
2131 GIC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES", "FOR"))
2132 UIC 0 : COMPLETE_WITH("ROLE");
2133 ECB : /* ALTER DEFAULT PRIVILEGES IN */
2134 GBC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN"))
2135 UIC 0 : COMPLETE_WITH("SCHEMA");
2136 ECB : /* ALTER DEFAULT PRIVILEGES FOR ROLE|USER ... */
2137 GBC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES", "FOR", "ROLE|USER",
2138 : MatchAny))
2139 LBC 0 : COMPLETE_WITH("GRANT", "REVOKE", "IN SCHEMA");
2140 : /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... */
2141 GIC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN", "SCHEMA",
2142 : MatchAny))
2143 UIC 0 : COMPLETE_WITH("GRANT", "REVOKE", "FOR ROLE");
2144 ECB : /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... FOR */
2145 GBC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN", "SCHEMA",
2146 : MatchAny, "FOR"))
2147 LBC 0 : COMPLETE_WITH("ROLE");
2148 EUB : /* ALTER DEFAULT PRIVILEGES FOR ROLE|USER ... IN SCHEMA ... */
2149 : /* ALTER DEFAULT PRIVILEGES IN SCHEMA ... FOR ROLE|USER ... */
2150 CBC 60 : else if (Matches("ALTER", "DEFAULT", "PRIVILEGES", "FOR", "ROLE|USER",
2151 GBC 60 : MatchAny, "IN", "SCHEMA", MatchAny) ||
2152 GIC 60 : Matches("ALTER", "DEFAULT", "PRIVILEGES", "IN", "SCHEMA",
2153 : MatchAny, "FOR", "ROLE|USER", MatchAny))
2154 UIC 0 : COMPLETE_WITH("GRANT", "REVOKE");
2155 : /* ALTER DOMAIN <name> */
2156 GIC 60 : else if (Matches("ALTER", "DOMAIN", MatchAny))
2157 LBC 0 : COMPLETE_WITH("ADD", "DROP", "OWNER TO", "RENAME", "SET",
2158 EUB : "VALIDATE CONSTRAINT");
2159 : /* ALTER DOMAIN <sth> DROP */
2160 GIC 60 : else if (Matches("ALTER", "DOMAIN", MatchAny, "DROP"))
2161 UIC 0 : COMPLETE_WITH("CONSTRAINT", "DEFAULT", "NOT NULL");
2162 : /* ALTER DOMAIN <sth> DROP|RENAME|VALIDATE CONSTRAINT */
2163 GIC 60 : else if (Matches("ALTER", "DOMAIN", MatchAny, "DROP|RENAME|VALIDATE", "CONSTRAINT"))
2164 ECB : {
2165 UBC 0 : set_completion_reference(prev3_wd);
2166 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_type);
2167 EUB : }
2168 : /* ALTER DOMAIN <sth> RENAME */
2169 GIC 60 : else if (Matches("ALTER", "DOMAIN", MatchAny, "RENAME"))
2170 LBC 0 : COMPLETE_WITH("CONSTRAINT", "TO");
2171 EUB : /* ALTER DOMAIN <sth> RENAME CONSTRAINT <sth> */
2172 GIC 60 : else if (Matches("ALTER", "DOMAIN", MatchAny, "RENAME", "CONSTRAINT", MatchAny))
2173 UIC 0 : COMPLETE_WITH("TO");
2174 ECB :
2175 EUB : /* ALTER DOMAIN <sth> SET */
2176 GIC 60 : else if (Matches("ALTER", "DOMAIN", MatchAny, "SET"))
2177 UIC 0 : COMPLETE_WITH("DEFAULT", "NOT NULL", "SCHEMA");
2178 ECB : /* ALTER SEQUENCE <name> */
2179 GBC 60 : else if (Matches("ALTER", "SEQUENCE", MatchAny))
2180 UIC 0 : COMPLETE_WITH("AS", "INCREMENT", "MINVALUE", "MAXVALUE", "RESTART",
2181 : "START", "NO", "CACHE", "CYCLE", "SET", "OWNED BY",
2182 : "OWNER TO", "RENAME TO");
2183 ECB : /* ALTER SEQUENCE <name> AS */
2184 GBC 60 : else if (TailMatches("ALTER", "SEQUENCE", MatchAny, "AS"))
2185 UBC 0 : COMPLETE_WITH_CS("smallint", "integer", "bigint");
2186 : /* ALTER SEQUENCE <name> NO */
2187 GIC 60 : else if (Matches("ALTER", "SEQUENCE", MatchAny, "NO"))
2188 UIC 0 : COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE");
2189 : /* ALTER SEQUENCE <name> SET */
2190 GIC 60 : else if (Matches("ALTER", "SEQUENCE", MatchAny, "SET"))
2191 UIC 0 : COMPLETE_WITH("SCHEMA", "LOGGED", "UNLOGGED");
2192 : /* ALTER SERVER <name> */
2193 CBC 60 : else if (Matches("ALTER", "SERVER", MatchAny))
2194 UIC 0 : COMPLETE_WITH("VERSION", "OPTIONS", "OWNER TO", "RENAME TO");
2195 EUB : /* ALTER SERVER <name> VERSION <version> */
2196 GIC 60 : else if (Matches("ALTER", "SERVER", MatchAny, "VERSION", MatchAny))
2197 UIC 0 : COMPLETE_WITH("OPTIONS");
2198 : /* ALTER SYSTEM SET, RESET, RESET ALL */
2199 GIC 60 : else if (Matches("ALTER", "SYSTEM"))
2200 UIC 0 : COMPLETE_WITH("SET", "RESET");
2201 GIC 60 : else if (Matches("ALTER", "SYSTEM", "SET|RESET"))
2202 UIC 0 : COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_alter_system_set_vars,
2203 ECB : "ALL");
2204 GBC 60 : else if (Matches("ALTER", "SYSTEM", "SET", MatchAny))
2205 UIC 0 : COMPLETE_WITH("TO");
2206 ECB : /* ALTER VIEW <name> */
2207 GBC 60 : else if (Matches("ALTER", "VIEW", MatchAny))
2208 UIC 0 : COMPLETE_WITH("ALTER COLUMN", "OWNER TO", "RENAME",
2209 ECB : "SET SCHEMA");
2210 EUB : /* ALTER VIEW xxx RENAME */
2211 GIC 60 : else if (Matches("ALTER", "VIEW", MatchAny, "RENAME"))
2212 LBC 0 : COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "TO");
2213 GIC 60 : else if (Matches("ALTER", "VIEW", MatchAny, "ALTER|RENAME", "COLUMN"))
2214 UBC 0 : COMPLETE_WITH_ATTR(prev3_wd);
2215 : /* ALTER VIEW xxx ALTER [ COLUMN ] yyy */
2216 CBC 120 : else if (Matches("ALTER", "VIEW", MatchAny, "ALTER", MatchAny) ||
2217 GIC 60 : Matches("ALTER", "VIEW", MatchAny, "ALTER", "COLUMN", MatchAny))
2218 UBC 0 : COMPLETE_WITH("SET DEFAULT", "DROP DEFAULT");
2219 : /* ALTER VIEW xxx RENAME yyy */
2220 CBC 60 : else if (Matches("ALTER", "VIEW", MatchAny, "RENAME", MatchAnyExcept("TO")))
2221 UIC 0 : COMPLETE_WITH("TO");
2222 EUB : /* ALTER VIEW xxx RENAME COLUMN yyy */
2223 GIC 60 : else if (Matches("ALTER", "VIEW", MatchAny, "RENAME", "COLUMN", MatchAnyExcept("TO")))
2224 UIC 0 : COMPLETE_WITH("TO");
2225 ECB :
2226 : /* ALTER MATERIALIZED VIEW <name> */
2227 CBC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny))
2228 UIC 0 : COMPLETE_WITH("ALTER COLUMN", "CLUSTER ON", "DEPENDS ON EXTENSION",
2229 EUB : "NO DEPENDS ON EXTENSION", "OWNER TO", "RENAME",
2230 : "RESET (", "SET");
2231 ECB : /* ALTER MATERIALIZED VIEW xxx RENAME */
2232 GBC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "RENAME"))
2233 UIC 0 : COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "TO");
2234 GIC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "ALTER|RENAME", "COLUMN"))
2235 LBC 0 : COMPLETE_WITH_ATTR(prev3_wd);
2236 EUB : /* ALTER MATERIALIZED VIEW xxx RENAME yyy */
2237 GIC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "RENAME", MatchAnyExcept("TO")))
2238 LBC 0 : COMPLETE_WITH("TO");
2239 : /* ALTER MATERIALIZED VIEW xxx RENAME COLUMN yyy */
2240 GBC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "RENAME", "COLUMN", MatchAnyExcept("TO")))
2241 UBC 0 : COMPLETE_WITH("TO");
2242 : /* ALTER MATERIALIZED VIEW xxx SET */
2243 GIC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "SET"))
2244 LBC 0 : COMPLETE_WITH("(", "ACCESS METHOD", "SCHEMA", "TABLESPACE", "WITHOUT CLUSTER");
2245 EUB : /* ALTER MATERIALIZED VIEW xxx SET ACCESS METHOD */
2246 GIC 60 : else if (Matches("ALTER", "MATERIALIZED", "VIEW", MatchAny, "SET", "ACCESS", "METHOD"))
2247 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods);
2248 EUB :
2249 : /* ALTER POLICY <name> */
2250 GIC 60 : else if (Matches("ALTER", "POLICY"))
2251 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_policies);
2252 EUB : /* ALTER POLICY <name> ON */
2253 GIC 60 : else if (Matches("ALTER", "POLICY", MatchAny))
2254 LBC 0 : COMPLETE_WITH("ON");
2255 EUB : /* ALTER POLICY <name> ON <table> */
2256 GIC 60 : else if (Matches("ALTER", "POLICY", MatchAny, "ON"))
2257 : {
2258 UIC 0 : set_completion_reference(prev2_wd);
2259 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy);
2260 EUB : }
2261 : /* ALTER POLICY <name> ON <table> - show options */
2262 CBC 60 : else if (Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny))
2263 UBC 0 : COMPLETE_WITH("RENAME TO", "TO", "USING (", "WITH CHECK (");
2264 : /* ALTER POLICY <name> ON <table> TO <role> */
2265 CBC 60 : else if (Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny, "TO"))
2266 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
2267 : Keywords_for_list_of_grant_roles);
2268 ECB : /* ALTER POLICY <name> ON <table> USING ( */
2269 GBC 60 : else if (Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny, "USING"))
2270 UIC 0 : COMPLETE_WITH("(");
2271 ECB : /* ALTER POLICY <name> ON <table> WITH CHECK ( */
2272 GBC 60 : else if (Matches("ALTER", "POLICY", MatchAny, "ON", MatchAny, "WITH", "CHECK"))
2273 UIC 0 : COMPLETE_WITH("(");
2274 ECB :
2275 EUB : /* ALTER RULE <name>, add ON */
2276 CBC 60 : else if (Matches("ALTER", "RULE", MatchAny))
2277 UBC 0 : COMPLETE_WITH("ON");
2278 :
2279 ECB : /* If we have ALTER RULE <name> ON, then add the correct tablename */
2280 GBC 60 : else if (Matches("ALTER", "RULE", MatchAny, "ON"))
2281 : {
2282 LBC 0 : set_completion_reference(prev2_wd);
2283 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule);
2284 : }
2285 :
2286 ECB : /* ALTER RULE <name> ON <name> */
2287 GBC 60 : else if (Matches("ALTER", "RULE", MatchAny, "ON", MatchAny))
2288 LBC 0 : COMPLETE_WITH("RENAME TO");
2289 EUB :
2290 : /* ALTER STATISTICS <name> */
2291 CBC 60 : else if (Matches("ALTER", "STATISTICS", MatchAny))
2292 LBC 0 : COMPLETE_WITH("OWNER TO", "RENAME TO", "SET SCHEMA", "SET STATISTICS");
2293 : /* ALTER STATISTICS <name> SET */
2294 GNC 60 : else if (Matches("ALTER", "STATISTICS", MatchAny, "SET"))
2295 UNC 0 : COMPLETE_WITH("SCHEMA", "STATISTICS");
2296 EUB :
2297 : /* ALTER TRIGGER <name>, add ON */
2298 CBC 60 : else if (Matches("ALTER", "TRIGGER", MatchAny))
2299 UBC 0 : COMPLETE_WITH("ON");
2300 :
2301 CBC 60 : else if (Matches("ALTER", "TRIGGER", MatchAny, "ON"))
2302 EUB : {
2303 UIC 0 : set_completion_reference(prev2_wd);
2304 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger);
2305 ECB : }
2306 EUB :
2307 : /* ALTER TRIGGER <name> ON <name> */
2308 GIC 60 : else if (Matches("ALTER", "TRIGGER", MatchAny, "ON", MatchAny))
2309 UIC 0 : COMPLETE_WITH("RENAME TO", "DEPENDS ON EXTENSION",
2310 ECB : "NO DEPENDS ON EXTENSION");
2311 EUB :
2312 ECB : /*
2313 EUB : * If we detect ALTER TABLE <name>, suggest sub commands
2314 : */
2315 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny))
2316 UBC 0 : COMPLETE_WITH("ADD", "ALTER", "CLUSTER ON", "DISABLE", "DROP",
2317 : "ENABLE", "INHERIT", "NO", "RENAME", "RESET",
2318 ECB : "OWNER TO", "SET", "VALIDATE CONSTRAINT",
2319 EUB : "REPLICA IDENTITY", "ATTACH PARTITION",
2320 : "DETACH PARTITION", "FORCE ROW LEVEL SECURITY",
2321 : "OF", "NOT OF");
2322 ECB : /* ALTER TABLE xxx ADD */
2323 GBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD"))
2324 : {
2325 ECB : /* make sure to keep this list and the !Matches() below in sync */
2326 UBC 0 : COMPLETE_WITH("COLUMN", "CONSTRAINT", "CHECK", "UNIQUE", "PRIMARY KEY",
2327 : "EXCLUDE", "FOREIGN KEY");
2328 : }
2329 ECB : /* ALTER TABLE xxx ADD [COLUMN] yyy */
2330 GBC 120 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "COLUMN", MatchAny) ||
2331 GIC 60 : (Matches("ALTER", "TABLE", MatchAny, "ADD", MatchAny) &&
2332 LBC 0 : !Matches("ALTER", "TABLE", MatchAny, "ADD", "COLUMN|CONSTRAINT|CHECK|UNIQUE|PRIMARY|EXCLUDE|FOREIGN")))
2333 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
2334 : /* ALTER TABLE xxx ADD CONSTRAINT yyy */
2335 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny))
2336 UIC 0 : COMPLETE_WITH("CHECK", "UNIQUE", "PRIMARY KEY", "EXCLUDE", "FOREIGN KEY");
2337 EUB : /* ALTER TABLE xxx ADD [CONSTRAINT yyy] (PRIMARY KEY|UNIQUE) */
2338 GBC 120 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "PRIMARY", "KEY") ||
2339 GIC 120 : Matches("ALTER", "TABLE", MatchAny, "ADD", "UNIQUE") ||
2340 120 : Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny, "PRIMARY", "KEY") ||
2341 CBC 60 : Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny, "UNIQUE"))
2342 UBC 0 : COMPLETE_WITH("(", "USING INDEX");
2343 : /* ALTER TABLE xxx ADD PRIMARY KEY USING INDEX */
2344 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "PRIMARY", "KEY", "USING", "INDEX"))
2345 EUB : {
2346 UIC 0 : set_completion_reference(prev6_wd);
2347 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table);
2348 ECB : }
2349 EUB : /* ALTER TABLE xxx ADD UNIQUE USING INDEX */
2350 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "UNIQUE", "USING", "INDEX"))
2351 ECB : {
2352 UBC 0 : set_completion_reference(prev5_wd);
2353 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table);
2354 : }
2355 ECB : /* ALTER TABLE xxx ADD CONSTRAINT yyy PRIMARY KEY USING INDEX */
2356 GBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny,
2357 : "PRIMARY", "KEY", "USING", "INDEX"))
2358 : {
2359 LBC 0 : set_completion_reference(prev8_wd);
2360 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table);
2361 EUB : }
2362 : /* ALTER TABLE xxx ADD CONSTRAINT yyy UNIQUE USING INDEX */
2363 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ADD", "CONSTRAINT", MatchAny,
2364 : "UNIQUE", "USING", "INDEX"))
2365 : {
2366 LBC 0 : set_completion_reference(prev7_wd);
2367 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_unique_index_of_table);
2368 : }
2369 : /* ALTER TABLE xxx ENABLE */
2370 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ENABLE"))
2371 UBC 0 : COMPLETE_WITH("ALWAYS", "REPLICA", "ROW LEVEL SECURITY", "RULE",
2372 : "TRIGGER");
2373 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ENABLE", "REPLICA|ALWAYS"))
2374 UBC 0 : COMPLETE_WITH("RULE", "TRIGGER");
2375 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ENABLE", "RULE"))
2376 : {
2377 LBC 0 : set_completion_reference(prev3_wd);
2378 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table);
2379 : }
2380 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ENABLE", MatchAny, "RULE"))
2381 : {
2382 UBC 0 : set_completion_reference(prev4_wd);
2383 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table);
2384 : }
2385 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ENABLE", "TRIGGER"))
2386 : {
2387 LBC 0 : set_completion_reference(prev3_wd);
2388 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table);
2389 : }
2390 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ENABLE", MatchAny, "TRIGGER"))
2391 : {
2392 UIC 0 : set_completion_reference(prev4_wd);
2393 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table);
2394 ECB : }
2395 EUB : /* ALTER TABLE xxx INHERIT */
2396 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "INHERIT"))
2397 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
2398 : /* ALTER TABLE xxx NO */
2399 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "NO"))
2400 UIC 0 : COMPLETE_WITH("FORCE ROW LEVEL SECURITY", "INHERIT");
2401 : /* ALTER TABLE xxx NO INHERIT */
2402 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "NO", "INHERIT"))
2403 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
2404 : /* ALTER TABLE xxx DISABLE */
2405 GBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "DISABLE"))
2406 UIC 0 : COMPLETE_WITH("ROW LEVEL SECURITY", "RULE", "TRIGGER");
2407 GIC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "DISABLE", "RULE"))
2408 : {
2409 LBC 0 : set_completion_reference(prev3_wd);
2410 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_rule_of_table);
2411 EUB : }
2412 GBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "DISABLE", "TRIGGER"))
2413 : {
2414 LBC 0 : set_completion_reference(prev3_wd);
2415 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_trigger_of_table);
2416 : }
2417 ECB :
2418 : /* ALTER TABLE xxx ALTER */
2419 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER"))
2420 LBC 0 : COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "CONSTRAINT");
2421 EUB :
2422 : /* ALTER TABLE xxx RENAME */
2423 CBC 60 : else if (Matches("ALTER", "TABLE", MatchAny, "RENAME"))
2424 GIC 12 : COMPLETE_WITH_ATTR_PLUS(prev2_wd, "COLUMN", "CONSTRAINT", "TO");
2425 GBC 48 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER|RENAME", "COLUMN"))
2426 UBC 0 : COMPLETE_WITH_ATTR(prev3_wd);
2427 :
2428 : /* ALTER TABLE xxx RENAME yyy */
2429 CBC 48 : else if (Matches("ALTER", "TABLE", MatchAny, "RENAME", MatchAnyExcept("CONSTRAINT|TO")))
2430 UIC 0 : COMPLETE_WITH("TO");
2431 EUB :
2432 : /* ALTER TABLE xxx RENAME COLUMN/CONSTRAINT yyy */
2433 GIC 48 : else if (Matches("ALTER", "TABLE", MatchAny, "RENAME", "COLUMN|CONSTRAINT", MatchAnyExcept("TO")))
2434 UIC 0 : COMPLETE_WITH("TO");
2435 ECB :
2436 : /* If we have ALTER TABLE <sth> DROP, provide COLUMN or CONSTRAINT */
2437 GIC 48 : else if (Matches("ALTER", "TABLE", MatchAny, "DROP"))
2438 UBC 0 : COMPLETE_WITH("COLUMN", "CONSTRAINT");
2439 EUB : /* If we have ALTER TABLE <sth> DROP COLUMN, provide list of columns */
2440 GIC 48 : else if (Matches("ALTER", "TABLE", MatchAny, "DROP", "COLUMN"))
2441 UIC 0 : COMPLETE_WITH_ATTR(prev3_wd);
2442 ECB : /* ALTER TABLE <sth> ALTER|DROP|RENAME CONSTRAINT <constraint> */
2443 GIC 48 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER|DROP|RENAME", "CONSTRAINT"))
2444 : {
2445 GBC 3 : set_completion_reference(prev3_wd);
2446 3 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_table);
2447 : }
2448 : /* ALTER TABLE <sth> VALIDATE CONSTRAINT <non-validated constraint> */
2449 CBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "VALIDATE", "CONSTRAINT"))
2450 EUB : {
2451 UIC 0 : set_completion_reference(prev3_wd);
2452 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_constraint_of_table_not_validated);
2453 EUB : }
2454 ECB : /* ALTER TABLE ALTER [COLUMN] <foo> */
2455 GIC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny) ||
2456 GBC 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny))
2457 UBC 0 : COMPLETE_WITH("TYPE", "SET", "RESET", "RESTART", "ADD", "DROP");
2458 : /* ALTER TABLE ALTER [COLUMN] <foo> ADD */
2459 GNC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD") ||
2460 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD"))
2461 UNC 0 : COMPLETE_WITH("GENERATED");
2462 : /* ALTER TABLE ALTER [COLUMN] <foo> ADD GENERATED */
2463 GNC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD", "GENERATED") ||
2464 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD", "GENERATED"))
2465 UNC 0 : COMPLETE_WITH("ALWAYS", "BY DEFAULT");
2466 : /* ALTER TABLE ALTER [COLUMN] <foo> ADD GENERATED */
2467 GNC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD", "GENERATED", "ALWAYS") ||
2468 90 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD", "GENERATED", "ALWAYS") ||
2469 90 : Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "ADD", "GENERATED", "BY", "DEFAULT") ||
2470 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "ADD", "GENERATED", "BY", "DEFAULT"))
2471 UNC 0 : COMPLETE_WITH("AS IDENTITY");
2472 : /* ALTER TABLE ALTER [COLUMN] <foo> SET */
2473 CBC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET") ||
2474 GIC 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET"))
2475 UNC 0 : COMPLETE_WITH("(", "COMPRESSION", "DEFAULT", "GENERATED", "NOT NULL", "STATISTICS", "STORAGE",
2476 : /* a subset of ALTER SEQUENCE options */
2477 : "INCREMENT", "MINVALUE", "MAXVALUE", "START", "NO", "CACHE", "CYCLE");
2478 EUB : /* ALTER TABLE ALTER [COLUMN] <foo> SET ( */
2479 GIC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "(") ||
2480 CBC 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "("))
2481 UIC 0 : COMPLETE_WITH("n_distinct", "n_distinct_inherited");
2482 : /* ALTER TABLE ALTER [COLUMN] <foo> SET COMPRESSION */
2483 GNC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "COMPRESSION") ||
2484 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "COMPRESSION"))
2485 UNC 0 : COMPLETE_WITH("DEFAULT", "PGLZ", "LZ4");
2486 : /* ALTER TABLE ALTER [COLUMN] <foo> SET GENERATED */
2487 GNC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "GENERATED") ||
2488 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "GENERATED"))
2489 UNC 0 : COMPLETE_WITH("ALWAYS", "BY DEFAULT");
2490 : /* ALTER TABLE ALTER [COLUMN] <foo> SET NO */
2491 GNC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "NO") ||
2492 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "NO"))
2493 UNC 0 : COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE");
2494 EUB : /* ALTER TABLE ALTER [COLUMN] <foo> SET STORAGE */
2495 GBC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "STORAGE") ||
2496 GIC 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "STORAGE"))
2497 UNC 0 : COMPLETE_WITH("DEFAULT", "PLAIN", "EXTERNAL", "EXTENDED", "MAIN");
2498 : /* ALTER TABLE ALTER [COLUMN] <foo> SET STATISTICS */
2499 GBC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "STATISTICS") ||
2500 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "STATISTICS"))
2501 : {
2502 : /* Enforce no completion here, as an integer has to be specified */
2503 ECB : }
2504 EUB : /* ALTER TABLE ALTER [COLUMN] <foo> DROP */
2505 GIC 90 : else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "DROP") ||
2506 CBC 45 : Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "DROP"))
2507 UBC 0 : COMPLETE_WITH("DEFAULT", "EXPRESSION", "IDENTITY", "NOT NULL");
2508 GIC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "CLUSTER"))
2509 LBC 0 : COMPLETE_WITH("ON");
2510 GBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "CLUSTER", "ON"))
2511 : {
2512 LBC 0 : set_completion_reference(prev3_wd);
2513 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table);
2514 ECB : }
2515 : /* If we have ALTER TABLE <sth> SET, provide list of attributes and '(' */
2516 GBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "SET"))
2517 UBC 0 : COMPLETE_WITH("(", "ACCESS METHOD", "LOGGED", "SCHEMA",
2518 : "TABLESPACE", "UNLOGGED", "WITH", "WITHOUT");
2519 ECB :
2520 : /*
2521 EUB : * If we have ALTER TABLE <sth> SET ACCESS METHOD provide a list of table
2522 : * AMs.
2523 : */
2524 GIC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "SET", "ACCESS", "METHOD"))
2525 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods);
2526 ECB :
2527 EUB : /*
2528 : * If we have ALTER TABLE <sth> SET TABLESPACE provide a list of
2529 : * tablespaces
2530 ECB : */
2531 CBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "SET", "TABLESPACE"))
2532 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
2533 EUB : /* If we have ALTER TABLE <sth> SET WITHOUT provide CLUSTER or OIDS */
2534 GIC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "SET", "WITHOUT"))
2535 UIC 0 : COMPLETE_WITH("CLUSTER", "OIDS");
2536 ECB : /* ALTER TABLE <foo> RESET */
2537 GBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "RESET"))
2538 UIC 0 : COMPLETE_WITH("(");
2539 : /* ALTER TABLE <foo> SET|RESET ( */
2540 CBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "SET|RESET", "("))
2541 UBC 0 : COMPLETE_WITH_LIST(table_storage_parameters);
2542 GIC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "REPLICA", "IDENTITY", "USING", "INDEX"))
2543 : {
2544 LBC 0 : set_completion_reference(prev5_wd);
2545 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table);
2546 : }
2547 CBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "REPLICA", "IDENTITY", "USING"))
2548 UBC 0 : COMPLETE_WITH("INDEX");
2549 GIC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "REPLICA", "IDENTITY"))
2550 LBC 0 : COMPLETE_WITH("FULL", "NOTHING", "DEFAULT", "USING");
2551 GIC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "REPLICA"))
2552 LBC 0 : COMPLETE_WITH("IDENTITY");
2553 ECB :
2554 : /*
2555 : * If we have ALTER TABLE <foo> ATTACH PARTITION, provide a list of
2556 : * tables.
2557 : */
2558 GBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "ATTACH", "PARTITION"))
2559 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
2560 : /* Limited completion support for partition bound specification */
2561 GIC 45 : else if (TailMatches("ATTACH", "PARTITION", MatchAny))
2562 LBC 0 : COMPLETE_WITH("FOR VALUES", "DEFAULT");
2563 CBC 45 : else if (TailMatches("FOR", "VALUES"))
2564 UBC 0 : COMPLETE_WITH("FROM (", "IN (", "WITH (");
2565 :
2566 ECB : /*
2567 : * If we have ALTER TABLE <foo> DETACH PARTITION, provide a list of
2568 EUB : * partitions of <foo>.
2569 : */
2570 CBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "DETACH", "PARTITION"))
2571 ECB : {
2572 UBC 0 : set_completion_reference(prev3_wd);
2573 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_partition_of_table);
2574 ECB : }
2575 CBC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "DETACH", "PARTITION", MatchAny))
2576 LBC 0 : COMPLETE_WITH("CONCURRENTLY", "FINALIZE");
2577 ECB :
2578 : /* ALTER TABLE <name> OF */
2579 GNC 45 : else if (Matches("ALTER", "TABLE", MatchAny, "OF"))
2580 UNC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_composite_datatypes);
2581 :
2582 EUB : /* ALTER TABLESPACE <foo> with RENAME TO, OWNER TO, SET, RESET */
2583 GIC 45 : else if (Matches("ALTER", "TABLESPACE", MatchAny))
2584 LBC 0 : COMPLETE_WITH("RENAME TO", "OWNER TO", "SET", "RESET");
2585 ECB : /* ALTER TABLESPACE <foo> SET|RESET */
2586 GBC 45 : else if (Matches("ALTER", "TABLESPACE", MatchAny, "SET|RESET"))
2587 UIC 0 : COMPLETE_WITH("(");
2588 : /* ALTER TABLESPACE <foo> SET|RESET ( */
2589 GIC 45 : else if (Matches("ALTER", "TABLESPACE", MatchAny, "SET|RESET", "("))
2590 LBC 0 : COMPLETE_WITH("seq_page_cost", "random_page_cost",
2591 ECB : "effective_io_concurrency", "maintenance_io_concurrency");
2592 EUB :
2593 : /* ALTER TEXT SEARCH */
2594 CBC 45 : else if (Matches("ALTER", "TEXT", "SEARCH"))
2595 LBC 0 : COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE");
2596 GBC 45 : else if (Matches("ALTER", "TEXT", "SEARCH", "TEMPLATE|PARSER", MatchAny))
2597 UIC 0 : COMPLETE_WITH("RENAME TO", "SET SCHEMA");
2598 CBC 45 : else if (Matches("ALTER", "TEXT", "SEARCH", "DICTIONARY", MatchAny))
2599 LBC 0 : COMPLETE_WITH("(", "OWNER TO", "RENAME TO", "SET SCHEMA");
2600 GBC 45 : else if (Matches("ALTER", "TEXT", "SEARCH", "CONFIGURATION", MatchAny))
2601 UIC 0 : COMPLETE_WITH("ADD MAPPING FOR", "ALTER MAPPING",
2602 ECB : "DROP MAPPING FOR",
2603 : "OWNER TO", "RENAME TO", "SET SCHEMA");
2604 EUB :
2605 : /* complete ALTER TYPE <foo> with actions */
2606 CBC 45 : else if (Matches("ALTER", "TYPE", MatchAny))
2607 LBC 0 : COMPLETE_WITH("ADD ATTRIBUTE", "ADD VALUE", "ALTER ATTRIBUTE",
2608 EUB : "DROP ATTRIBUTE",
2609 : "OWNER TO", "RENAME", "SET SCHEMA", "SET (");
2610 ECB : /* complete ALTER TYPE <foo> ADD with actions */
2611 CBC 45 : else if (Matches("ALTER", "TYPE", MatchAny, "ADD"))
2612 UIC 0 : COMPLETE_WITH("ATTRIBUTE", "VALUE");
2613 : /* ALTER TYPE <foo> RENAME */
2614 GIC 45 : else if (Matches("ALTER", "TYPE", MatchAny, "RENAME"))
2615 UIC 0 : COMPLETE_WITH("ATTRIBUTE", "TO", "VALUE");
2616 ECB : /* ALTER TYPE xxx RENAME (ATTRIBUTE|VALUE) yyy */
2617 CBC 45 : else if (Matches("ALTER", "TYPE", MatchAny, "RENAME", "ATTRIBUTE|VALUE", MatchAny))
2618 UBC 0 : COMPLETE_WITH("TO");
2619 ECB :
2620 EUB : /*
2621 ECB : * If we have ALTER TYPE <sth> ALTER/DROP/RENAME ATTRIBUTE, provide list
2622 : * of attributes
2623 EUB : */
2624 GBC 45 : else if (Matches("ALTER", "TYPE", MatchAny, "ALTER|DROP|RENAME", "ATTRIBUTE"))
2625 UIC 0 : COMPLETE_WITH_ATTR(prev3_wd);
2626 : /* ALTER TYPE ALTER ATTRIBUTE <foo> */
2627 CBC 45 : else if (Matches("ALTER", "TYPE", MatchAny, "ALTER", "ATTRIBUTE", MatchAny))
2628 UBC 0 : COMPLETE_WITH("TYPE");
2629 : /* complete ALTER TYPE <sth> RENAME VALUE with list of enum values */
2630 GNC 45 : else if (Matches("ALTER", "TYPE", MatchAny, "RENAME", "VALUE"))
2631 3 : COMPLETE_WITH_ENUM_VALUE(prev3_wd);
2632 : /* ALTER TYPE <foo> SET */
2633 42 : else if (Matches("ALTER", "TYPE", MatchAny, "SET"))
2634 UNC 0 : COMPLETE_WITH("(", "SCHEMA");
2635 : /* complete ALTER TYPE <foo> SET ( with settable properties */
2636 GNC 42 : else if (Matches("ALTER", "TYPE", MatchAny, "SET", "("))
2637 UNC 0 : COMPLETE_WITH("ANALYZE", "RECEIVE", "SEND", "STORAGE", "SUBSCRIPT",
2638 : "TYPMOD_IN", "TYPMOD_OUT");
2639 :
2640 : /* complete ALTER GROUP <foo> */
2641 GIC 42 : else if (Matches("ALTER", "GROUP", MatchAny))
2642 UIC 0 : COMPLETE_WITH("ADD USER", "DROP USER", "RENAME TO");
2643 : /* complete ALTER GROUP <foo> ADD|DROP with USER */
2644 GIC 42 : else if (Matches("ALTER", "GROUP", MatchAny, "ADD|DROP"))
2645 UIC 0 : COMPLETE_WITH("USER");
2646 ECB : /* complete ALTER GROUP <foo> ADD|DROP USER with a user name */
2647 GBC 42 : else if (Matches("ALTER", "GROUP", MatchAny, "ADD|DROP", "USER"))
2648 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
2649 :
2650 ECB : /*
2651 EUB : * ANALYZE [ ( option [, ...] ) ] [ table_and_columns [, ...] ]
2652 : * ANALYZE [ VERBOSE ] [ table_and_columns [, ...] ]
2653 ECB : */
2654 GBC 42 : else if (Matches("ANALYZE"))
2655 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_analyzables,
2656 ECB : "VERBOSE");
2657 GBC 42 : else if (HeadMatches("ANALYZE", "(*") &&
2658 CBC 2 : !HeadMatches("ANALYZE", "(*)"))
2659 : {
2660 EUB : /*
2661 : * This fires if we're in an unfinished parenthesized option list.
2662 : * get_previous_words treats a completed parenthesized option list as
2663 ECB : * one word, so the above test is correct.
2664 EUB : */
2665 CBC 2 : if (ends_with(prev_wd, '(') || ends_with(prev_wd, ','))
2666 GNC 2 : COMPLETE_WITH("VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT");
2667 LBC 0 : else if (TailMatches("VERBOSE|SKIP_LOCKED"))
2668 UBC 0 : COMPLETE_WITH("ON", "OFF");
2669 : }
2670 GIC 40 : else if (HeadMatches("ANALYZE") && TailMatches("("))
2671 : /* "ANALYZE (" should be caught above, so assume we want columns */
2672 UIC 0 : COMPLETE_WITH_ATTR(prev2_wd);
2673 GIC 40 : else if (HeadMatches("ANALYZE"))
2674 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_analyzables);
2675 EUB :
2676 : /* BEGIN */
2677 CBC 40 : else if (Matches("BEGIN"))
2678 UBC 0 : COMPLETE_WITH("WORK", "TRANSACTION", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE");
2679 ECB : /* END, ABORT */
2680 GBC 40 : else if (Matches("END|ABORT"))
2681 UIC 0 : COMPLETE_WITH("AND", "WORK", "TRANSACTION");
2682 : /* COMMIT */
2683 GIC 40 : else if (Matches("COMMIT"))
2684 UIC 0 : COMPLETE_WITH("AND", "WORK", "TRANSACTION", "PREPARED");
2685 : /* RELEASE SAVEPOINT */
2686 CBC 40 : else if (Matches("RELEASE"))
2687 UIC 0 : COMPLETE_WITH("SAVEPOINT");
2688 EUB : /* ROLLBACK */
2689 GBC 40 : else if (Matches("ROLLBACK"))
2690 UIC 0 : COMPLETE_WITH("AND", "WORK", "TRANSACTION", "TO SAVEPOINT", "PREPARED");
2691 CBC 40 : else if (Matches("ABORT|END|COMMIT|ROLLBACK", "AND"))
2692 UBC 0 : COMPLETE_WITH("CHAIN");
2693 : /* CALL */
2694 GIC 40 : else if (Matches("CALL"))
2695 LBC 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures);
2696 GBC 40 : else if (Matches("CALL", MatchAny))
2697 UIC 0 : COMPLETE_WITH("(");
2698 : /* CLOSE */
2699 CBC 40 : else if (Matches("CLOSE"))
2700 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors,
2701 : "ALL");
2702 ECB : /* CLUSTER */
2703 GBC 40 : else if (Matches("CLUSTER"))
2704 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_clusterables,
2705 ECB : "VERBOSE");
2706 GBC 80 : else if (Matches("CLUSTER", "VERBOSE") ||
2707 GIC 40 : Matches("CLUSTER", "(*)"))
2708 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_clusterables);
2709 : /* If we have CLUSTER <sth>, then add "USING" */
2710 CBC 40 : else if (Matches("CLUSTER", MatchAnyExcept("VERBOSE|ON|(|(*)")))
2711 UBC 0 : COMPLETE_WITH("USING");
2712 ECB : /* If we have CLUSTER VERBOSE <sth>, then add "USING" */
2713 GBC 40 : else if (Matches("CLUSTER", "VERBOSE|(*)", MatchAny))
2714 LBC 0 : COMPLETE_WITH("USING");
2715 EUB : /* If we have CLUSTER <sth> USING, then add the index as well */
2716 CBC 80 : else if (Matches("CLUSTER", MatchAny, "USING") ||
2717 GBC 40 : Matches("CLUSTER", "VERBOSE|(*)", MatchAny, "USING"))
2718 : {
2719 UIC 0 : set_completion_reference(prev2_wd);
2720 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_index_of_table);
2721 : }
2722 CBC 40 : else if (HeadMatches("CLUSTER", "(*") &&
2723 UBC 0 : !HeadMatches("CLUSTER", "(*)"))
2724 : {
2725 : /*
2726 : * This fires if we're in an unfinished parenthesized option list.
2727 ECB : * get_previous_words treats a completed parenthesized option list as
2728 EUB : * one word, so the above test is correct.
2729 : */
2730 LBC 0 : if (ends_with(prev_wd, '(') || ends_with(prev_wd, ','))
2731 UBC 0 : COMPLETE_WITH("VERBOSE");
2732 : }
2733 ECB :
2734 EUB : /* COMMENT */
2735 GIC 40 : else if (Matches("COMMENT"))
2736 UIC 0 : COMPLETE_WITH("ON");
2737 GIC 40 : else if (Matches("COMMENT", "ON"))
2738 UIC 0 : COMPLETE_WITH("ACCESS METHOD", "AGGREGATE", "CAST", "COLLATION",
2739 : "COLUMN", "CONSTRAINT", "CONVERSION", "DATABASE",
2740 ECB : "DOMAIN", "EXTENSION", "EVENT TRIGGER",
2741 EUB : "FOREIGN DATA WRAPPER", "FOREIGN TABLE",
2742 : "FUNCTION", "INDEX", "LANGUAGE", "LARGE OBJECT",
2743 ECB : "MATERIALIZED VIEW", "OPERATOR", "POLICY",
2744 EUB : "PROCEDURE", "PROCEDURAL LANGUAGE", "PUBLICATION", "ROLE",
2745 : "ROUTINE", "RULE", "SCHEMA", "SEQUENCE", "SERVER",
2746 ECB : "STATISTICS", "SUBSCRIPTION", "TABLE",
2747 : "TABLESPACE", "TEXT SEARCH", "TRANSFORM FOR",
2748 : "TRIGGER", "TYPE", "VIEW");
2749 CBC 40 : else if (Matches("COMMENT", "ON", "ACCESS", "METHOD"))
2750 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_access_methods);
2751 GIC 40 : else if (Matches("COMMENT", "ON", "CONSTRAINT"))
2752 LBC 0 : COMPLETE_WITH_QUERY(Query_for_all_table_constraints);
2753 GBC 40 : else if (Matches("COMMENT", "ON", "CONSTRAINT", MatchAny))
2754 UIC 0 : COMPLETE_WITH("ON");
2755 GIC 40 : else if (Matches("COMMENT", "ON", "CONSTRAINT", MatchAny, "ON"))
2756 : {
2757 CBC 1 : set_completion_reference(prev2_wd);
2758 GBC 1 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables_for_constraint,
2759 : "DOMAIN");
2760 ECB : }
2761 GBC 39 : else if (Matches("COMMENT", "ON", "CONSTRAINT", MatchAny, "ON", "DOMAIN"))
2762 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains);
2763 CBC 39 : else if (Matches("COMMENT", "ON", "EVENT", "TRIGGER"))
2764 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
2765 GIC 39 : else if (Matches("COMMENT", "ON", "FOREIGN"))
2766 UIC 0 : COMPLETE_WITH("DATA WRAPPER", "TABLE");
2767 GIC 39 : else if (Matches("COMMENT", "ON", "FOREIGN", "TABLE"))
2768 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables);
2769 GIC 39 : else if (Matches("COMMENT", "ON", "MATERIALIZED", "VIEW"))
2770 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews);
2771 GBC 39 : else if (Matches("COMMENT", "ON", "POLICY"))
2772 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_policies);
2773 CBC 39 : else if (Matches("COMMENT", "ON", "POLICY", MatchAny))
2774 LBC 0 : COMPLETE_WITH("ON");
2775 GIC 39 : else if (Matches("COMMENT", "ON", "POLICY", MatchAny, "ON"))
2776 : {
2777 UIC 0 : set_completion_reference(prev2_wd);
2778 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy);
2779 : }
2780 GIC 39 : else if (Matches("COMMENT", "ON", "PROCEDURAL", "LANGUAGE"))
2781 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_languages);
2782 CBC 39 : else if (Matches("COMMENT", "ON", "RULE", MatchAny))
2783 UBC 0 : COMPLETE_WITH("ON");
2784 GBC 39 : else if (Matches("COMMENT", "ON", "RULE", MatchAny, "ON"))
2785 : {
2786 LBC 0 : set_completion_reference(prev2_wd);
2787 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule);
2788 EUB : }
2789 CBC 39 : else if (Matches("COMMENT", "ON", "TEXT", "SEARCH"))
2790 UBC 0 : COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE");
2791 GIC 39 : else if (Matches("COMMENT", "ON", "TEXT", "SEARCH", "CONFIGURATION"))
2792 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_configurations);
2793 CBC 39 : else if (Matches("COMMENT", "ON", "TEXT", "SEARCH", "DICTIONARY"))
2794 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_dictionaries);
2795 GIC 39 : else if (Matches("COMMENT", "ON", "TEXT", "SEARCH", "PARSER"))
2796 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_parsers);
2797 GBC 39 : else if (Matches("COMMENT", "ON", "TEXT", "SEARCH", "TEMPLATE"))
2798 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_templates);
2799 CBC 39 : else if (Matches("COMMENT", "ON", "TRANSFORM", "FOR"))
2800 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
2801 GIC 39 : else if (Matches("COMMENT", "ON", "TRANSFORM", "FOR", MatchAny))
2802 LBC 0 : COMPLETE_WITH("LANGUAGE");
2803 GBC 39 : else if (Matches("COMMENT", "ON", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"))
2804 : {
2805 LBC 0 : set_completion_reference(prev2_wd);
2806 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_languages);
2807 ECB : }
2808 GBC 39 : else if (Matches("COMMENT", "ON", "TRIGGER", MatchAny))
2809 UIC 0 : COMPLETE_WITH("ON");
2810 CBC 39 : else if (Matches("COMMENT", "ON", "TRIGGER", MatchAny, "ON"))
2811 EUB : {
2812 LBC 0 : set_completion_reference(prev2_wd);
2813 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger);
2814 : }
2815 CBC 78 : else if (Matches("COMMENT", "ON", MatchAny, MatchAnyExcept("IS")) ||
2816 GBC 78 : Matches("COMMENT", "ON", MatchAny, MatchAny, MatchAnyExcept("IS")) ||
2817 GIC 78 : Matches("COMMENT", "ON", MatchAny, MatchAny, MatchAny, MatchAnyExcept("IS")) ||
2818 39 : Matches("COMMENT", "ON", MatchAny, MatchAny, MatchAny, MatchAny, MatchAnyExcept("IS")))
2819 LBC 0 : COMPLETE_WITH("IS");
2820 EUB :
2821 : /* COPY */
2822 ECB :
2823 : /*
2824 EUB : * If we have COPY, offer list of tables or "(" (Also cover the analogous
2825 : * backslash command).
2826 ECB : */
2827 GBC 39 : else if (Matches("COPY|\\copy"))
2828 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables, "(");
2829 ECB : /* Complete COPY ( with legal query commands */
2830 GBC 39 : else if (Matches("COPY|\\copy", "("))
2831 UIC 0 : COMPLETE_WITH("SELECT", "TABLE", "VALUES", "INSERT INTO", "UPDATE", "DELETE FROM", "WITH");
2832 ECB : /* Complete COPY <sth> */
2833 CBC 39 : else if (Matches("COPY|\\copy", MatchAny))
2834 UIC 0 : COMPLETE_WITH("FROM", "TO");
2835 EUB : /* Complete COPY <sth> FROM|TO with filename */
2836 GBC 39 : else if (Matches("COPY", MatchAny, "FROM|TO"))
2837 : {
2838 CBC 4 : completion_charp = "";
2839 GBC 4 : completion_force_quote = true; /* COPY requires quoted filename */
2840 GIC 4 : matches = rl_completion_matches(text, complete_from_files);
2841 : }
2842 35 : else if (Matches("\\copy", MatchAny, "FROM|TO"))
2843 : {
2844 UIC 0 : completion_charp = "";
2845 0 : completion_force_quote = false;
2846 UBC 0 : matches = rl_completion_matches(text, complete_from_files);
2847 EUB : }
2848 :
2849 : /* Complete COPY <sth> TO <sth> */
2850 GIC 35 : else if (Matches("COPY|\\copy", MatchAny, "TO", MatchAny))
2851 LBC 0 : COMPLETE_WITH("WITH (");
2852 EUB :
2853 ECB : /* Complete COPY <sth> FROM <sth> */
2854 GBC 35 : else if (Matches("COPY|\\copy", MatchAny, "FROM", MatchAny))
2855 UIC 0 : COMPLETE_WITH("WITH (", "WHERE");
2856 :
2857 : /* Complete COPY <sth> FROM|TO filename WITH ( */
2858 GIC 35 : else if (Matches("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "WITH", "("))
2859 1 : COMPLETE_WITH("FORMAT", "FREEZE", "DELIMITER", "NULL",
2860 : "HEADER", "QUOTE", "ESCAPE", "FORCE_QUOTE",
2861 : "FORCE_NOT_NULL", "FORCE_NULL", "ENCODING", "DEFAULT");
2862 :
2863 : /* Complete COPY <sth> FROM|TO filename WITH (FORMAT */
2864 34 : else if (Matches("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "WITH", "(", "FORMAT"))
2865 LBC 0 : COMPLETE_WITH("binary", "csv", "text");
2866 EUB :
2867 ECB : /* Complete COPY <sth> FROM <sth> WITH (<options>) */
2868 GBC 34 : else if (Matches("COPY|\\copy", MatchAny, "FROM", MatchAny, "WITH", MatchAny))
2869 LBC 0 : COMPLETE_WITH("WHERE");
2870 EUB :
2871 ECB : /* CREATE ACCESS METHOD */
2872 : /* Complete "CREATE ACCESS METHOD <name>" */
2873 CBC 34 : else if (Matches("CREATE", "ACCESS", "METHOD", MatchAny))
2874 LBC 0 : COMPLETE_WITH("TYPE");
2875 : /* Complete "CREATE ACCESS METHOD <name> TYPE" */
2876 GIC 34 : else if (Matches("CREATE", "ACCESS", "METHOD", MatchAny, "TYPE"))
2877 LBC 0 : COMPLETE_WITH("INDEX", "TABLE");
2878 EUB : /* Complete "CREATE ACCESS METHOD <name> TYPE <type>" */
2879 CBC 34 : else if (Matches("CREATE", "ACCESS", "METHOD", MatchAny, "TYPE", MatchAny))
2880 UBC 0 : COMPLETE_WITH("HANDLER");
2881 ECB :
2882 EUB : /* CREATE COLLATION */
2883 CBC 34 : else if (Matches("CREATE", "COLLATION", MatchAny))
2884 UBC 0 : COMPLETE_WITH("(", "FROM");
2885 CBC 34 : else if (Matches("CREATE", "COLLATION", MatchAny, "FROM"))
2886 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_collations);
2887 CBC 34 : else if (HeadMatches("CREATE", "COLLATION", MatchAny, "(*"))
2888 EUB : {
2889 LBC 0 : if (TailMatches("(|*,"))
2890 UBC 0 : COMPLETE_WITH("LOCALE =", "LC_COLLATE =", "LC_CTYPE =",
2891 ECB : "PROVIDER =", "DETERMINISTIC =");
2892 UIC 0 : else if (TailMatches("PROVIDER", "="))
2893 UBC 0 : COMPLETE_WITH("libc", "icu");
2894 0 : else if (TailMatches("DETERMINISTIC", "="))
2895 UIC 0 : COMPLETE_WITH("true", "false");
2896 ECB : }
2897 EUB :
2898 ECB : /* CREATE DATABASE */
2899 GBC 34 : else if (Matches("CREATE", "DATABASE", MatchAny))
2900 LBC 0 : COMPLETE_WITH("OWNER", "TEMPLATE", "ENCODING", "TABLESPACE",
2901 : "IS_TEMPLATE", "STRATEGY",
2902 EUB : "ALLOW_CONNECTIONS", "CONNECTION LIMIT",
2903 : "LC_COLLATE", "LC_CTYPE", "LOCALE", "OID",
2904 : "LOCALE_PROVIDER", "ICU_LOCALE");
2905 ECB :
2906 GBC 34 : else if (Matches("CREATE", "DATABASE", MatchAny, "TEMPLATE"))
2907 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_template_databases);
2908 GBC 34 : else if (Matches("CREATE", "DATABASE", MatchAny, "STRATEGY"))
2909 LBC 0 : COMPLETE_WITH("WAL_LOG", "FILE_COPY");
2910 EUB :
2911 ECB : /* CREATE DOMAIN */
2912 GBC 34 : else if (Matches("CREATE", "DOMAIN", MatchAny))
2913 LBC 0 : COMPLETE_WITH("AS");
2914 GBC 34 : else if (Matches("CREATE", "DOMAIN", MatchAny, "AS"))
2915 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
2916 GBC 34 : else if (Matches("CREATE", "DOMAIN", MatchAny, "AS", MatchAny))
2917 LBC 0 : COMPLETE_WITH("COLLATE", "DEFAULT", "CONSTRAINT",
2918 EUB : "NOT NULL", "NULL", "CHECK (");
2919 CBC 34 : else if (Matches("CREATE", "DOMAIN", MatchAny, "COLLATE"))
2920 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_collations);
2921 EUB :
2922 : /* CREATE EXTENSION */
2923 : /* Complete with available extensions rather than installed ones. */
2924 CBC 34 : else if (Matches("CREATE", "EXTENSION"))
2925 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_available_extensions);
2926 ECB : /* CREATE EXTENSION <name> */
2927 GIC 34 : else if (Matches("CREATE", "EXTENSION", MatchAny))
2928 UBC 0 : COMPLETE_WITH("WITH SCHEMA", "CASCADE", "VERSION");
2929 EUB : /* CREATE EXTENSION <name> VERSION */
2930 GIC 34 : else if (Matches("CREATE", "EXTENSION", MatchAny, "VERSION"))
2931 ECB : {
2932 LBC 0 : set_completion_reference(prev2_wd);
2933 0 : COMPLETE_WITH_QUERY(Query_for_list_of_available_extension_versions);
2934 ECB : }
2935 EUB :
2936 : /* CREATE FOREIGN */
2937 GIC 34 : else if (Matches("CREATE", "FOREIGN"))
2938 UIC 0 : COMPLETE_WITH("DATA WRAPPER", "TABLE");
2939 :
2940 : /* CREATE FOREIGN DATA WRAPPER */
2941 GIC 34 : else if (Matches("CREATE", "FOREIGN", "DATA", "WRAPPER", MatchAny))
2942 UIC 0 : COMPLETE_WITH("HANDLER", "VALIDATOR", "OPTIONS");
2943 ECB :
2944 EUB : /* CREATE FOREIGN TABLE */
2945 GIC 34 : else if (Matches("CREATE", "FOREIGN", "TABLE", MatchAny))
2946 LBC 0 : COMPLETE_WITH("(", "PARTITION OF");
2947 EUB :
2948 : /* CREATE INDEX --- is allowed inside CREATE SCHEMA, so use TailMatches */
2949 ECB : /* First off we complete CREATE UNIQUE with "INDEX" */
2950 GBC 34 : else if (TailMatches("CREATE", "UNIQUE"))
2951 UIC 0 : COMPLETE_WITH("INDEX");
2952 ECB :
2953 : /*
2954 : * If we have CREATE|UNIQUE INDEX, then add "ON", "CONCURRENTLY", and
2955 : * existing indexes
2956 : */
2957 GIC 34 : else if (TailMatches("CREATE|UNIQUE", "INDEX"))
2958 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes,
2959 : "ON", "CONCURRENTLY");
2960 EUB :
2961 : /*
2962 : * Complete ... INDEX|CONCURRENTLY [<name>] ON with a list of relations
2963 : * that indexes can be created on
2964 : */
2965 GIC 68 : else if (TailMatches("INDEX|CONCURRENTLY", MatchAny, "ON") ||
2966 CBC 34 : TailMatches("INDEX|CONCURRENTLY", "ON"))
2967 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexables);
2968 :
2969 : /*
2970 ECB : * Complete CREATE|UNIQUE INDEX CONCURRENTLY with "ON" and existing
2971 EUB : * indexes
2972 : */
2973 GIC 34 : else if (TailMatches("CREATE|UNIQUE", "INDEX", "CONCURRENTLY"))
2974 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes,
2975 ECB : "ON");
2976 : /* Complete CREATE|UNIQUE INDEX [CONCURRENTLY] <sth> with "ON" */
2977 GIC 68 : else if (TailMatches("CREATE|UNIQUE", "INDEX", MatchAny) ||
2978 34 : TailMatches("CREATE|UNIQUE", "INDEX", "CONCURRENTLY", MatchAny))
2979 UIC 0 : COMPLETE_WITH("ON");
2980 ECB :
2981 EUB : /*
2982 : * Complete INDEX <name> ON <table> with a list of table columns (which
2983 : * should really be in parens)
2984 ECB : */
2985 GBC 68 : else if (TailMatches("INDEX", MatchAny, "ON", MatchAny) ||
2986 GIC 34 : TailMatches("INDEX|CONCURRENTLY", "ON", MatchAny))
2987 UIC 0 : COMPLETE_WITH("(", "USING");
2988 GIC 68 : else if (TailMatches("INDEX", MatchAny, "ON", MatchAny, "(") ||
2989 CBC 34 : TailMatches("INDEX|CONCURRENTLY", "ON", MatchAny, "("))
2990 UBC 0 : COMPLETE_WITH_ATTR(prev2_wd);
2991 : /* same if you put in USING */
2992 CBC 34 : else if (TailMatches("ON", MatchAny, "USING", MatchAny, "("))
2993 UBC 0 : COMPLETE_WITH_ATTR(prev4_wd);
2994 : /* Complete USING with an index method */
2995 CBC 68 : else if (TailMatches("INDEX", MatchAny, MatchAny, "ON", MatchAny, "USING") ||
2996 GBC 68 : TailMatches("INDEX", MatchAny, "ON", MatchAny, "USING") ||
2997 GIC 34 : TailMatches("INDEX", "ON", MatchAny, "USING"))
2998 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_index_access_methods);
2999 CBC 34 : else if (TailMatches("ON", MatchAny, "USING", MatchAny) &&
3000 UBC 0 : !TailMatches("POLICY", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny) &&
3001 LBC 0 : !TailMatches("FOR", MatchAny, MatchAny, MatchAny))
3002 UBC 0 : COMPLETE_WITH("(");
3003 ECB :
3004 : /* CREATE OR REPLACE */
3005 GBC 34 : else if (Matches("CREATE", "OR"))
3006 UBC 0 : COMPLETE_WITH("REPLACE");
3007 :
3008 EUB : /* CREATE POLICY */
3009 : /* Complete "CREATE POLICY <name> ON" */
3010 GBC 34 : else if (Matches("CREATE", "POLICY", MatchAny))
3011 UBC 0 : COMPLETE_WITH("ON");
3012 : /* Complete "CREATE POLICY <name> ON <table>" */
3013 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON"))
3014 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
3015 ECB : /* Complete "CREATE POLICY <name> ON <table> AS|FOR|TO|USING|WITH CHECK" */
3016 GBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny))
3017 UIC 0 : COMPLETE_WITH("AS", "FOR", "TO", "USING (", "WITH CHECK (");
3018 : /* CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE */
3019 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS"))
3020 UIC 0 : COMPLETE_WITH("PERMISSIVE", "RESTRICTIVE");
3021 :
3022 ECB : /*
3023 EUB : * CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE
3024 ECB : * FOR|TO|USING|WITH CHECK
3025 EUB : */
3026 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny))
3027 UIC 0 : COMPLETE_WITH("FOR", "TO", "USING", "WITH CHECK");
3028 ECB : /* CREATE POLICY <name> ON <table> FOR ALL|SELECT|INSERT|UPDATE|DELETE */
3029 GBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR"))
3030 LBC 0 : COMPLETE_WITH("ALL", "SELECT", "INSERT", "UPDATE", "DELETE");
3031 EUB : /* Complete "CREATE POLICY <name> ON <table> FOR INSERT TO|WITH CHECK" */
3032 CBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR", "INSERT"))
3033 UBC 0 : COMPLETE_WITH("TO", "WITH CHECK (");
3034 : /* Complete "CREATE POLICY <name> ON <table> FOR SELECT|DELETE TO|USING" */
3035 CBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR", "SELECT|DELETE"))
3036 UBC 0 : COMPLETE_WITH("TO", "USING (");
3037 : /* CREATE POLICY <name> ON <table> FOR ALL|UPDATE TO|USING|WITH CHECK */
3038 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "FOR", "ALL|UPDATE"))
3039 UIC 0 : COMPLETE_WITH("TO", "USING (", "WITH CHECK (");
3040 ECB : /* Complete "CREATE POLICY <name> ON <table> TO <role>" */
3041 GBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "TO"))
3042 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
3043 ECB : Keywords_for_list_of_grant_roles);
3044 EUB : /* Complete "CREATE POLICY <name> ON <table> USING (" */
3045 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "USING"))
3046 LBC 0 : COMPLETE_WITH("(");
3047 :
3048 EUB : /*
3049 : * CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE FOR
3050 : * ALL|SELECT|INSERT|UPDATE|DELETE
3051 : */
3052 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR"))
3053 LBC 0 : COMPLETE_WITH("ALL", "SELECT", "INSERT", "UPDATE", "DELETE");
3054 EUB :
3055 : /*
3056 : * Complete "CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE FOR
3057 ECB : * INSERT TO|WITH CHECK"
3058 EUB : */
3059 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR", "INSERT"))
3060 UIC 0 : COMPLETE_WITH("TO", "WITH CHECK (");
3061 ECB :
3062 EUB : /*
3063 : * Complete "CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE FOR
3064 : * SELECT|DELETE TO|USING"
3065 : */
3066 CBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR", "SELECT|DELETE"))
3067 UBC 0 : COMPLETE_WITH("TO", "USING (");
3068 :
3069 : /*
3070 : * CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE FOR
3071 : * ALL|UPDATE TO|USING|WITH CHECK
3072 : */
3073 CBC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "FOR", "ALL|UPDATE"))
3074 UBC 0 : COMPLETE_WITH("TO", "USING (", "WITH CHECK (");
3075 :
3076 : /*
3077 : * Complete "CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE TO
3078 : * <role>"
3079 : */
3080 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "TO"))
3081 LBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
3082 ECB : Keywords_for_list_of_grant_roles);
3083 EUB :
3084 : /*
3085 : * Complete "CREATE POLICY <name> ON <table> AS PERMISSIVE|RESTRICTIVE
3086 : * USING ("
3087 : */
3088 GIC 34 : else if (Matches("CREATE", "POLICY", MatchAny, "ON", MatchAny, "AS", MatchAny, "USING"))
3089 LBC 0 : COMPLETE_WITH("(");
3090 EUB :
3091 :
3092 : /* CREATE PUBLICATION */
3093 CBC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny))
3094 LBC 0 : COMPLETE_WITH("FOR TABLE", "FOR ALL TABLES", "FOR TABLES IN SCHEMA", "WITH (");
3095 GBC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR"))
3096 UIC 0 : COMPLETE_WITH("TABLE", "ALL TABLES", "TABLES IN SCHEMA");
3097 GIC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "ALL"))
3098 UIC 0 : COMPLETE_WITH("TABLES");
3099 GIC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "ALL", "TABLES"))
3100 UIC 0 : COMPLETE_WITH("WITH (");
3101 CBC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLES"))
3102 LBC 0 : COMPLETE_WITH("IN SCHEMA");
3103 GBC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLE", MatchAny) && !ends_with(prev_wd, ','))
3104 LBC 0 : COMPLETE_WITH("WHERE (", "WITH (");
3105 ECB : /* Complete "CREATE PUBLICATION <name> FOR TABLE" with "<table>, ..." */
3106 GBC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLE"))
3107 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
3108 ECB :
3109 EUB : /*
3110 : * "CREATE PUBLICATION <name> FOR TABLE <name> WHERE (" - complete with
3111 ECB : * table attributes
3112 : */
3113 CBC 34 : else if (HeadMatches("CREATE", "PUBLICATION", MatchAny) && TailMatches("WHERE"))
3114 UBC 0 : COMPLETE_WITH("(");
3115 CBC 34 : else if (HeadMatches("CREATE", "PUBLICATION", MatchAny) && TailMatches("WHERE", "("))
3116 UBC 0 : COMPLETE_WITH_ATTR(prev3_wd);
3117 GBC 34 : else if (HeadMatches("CREATE", "PUBLICATION", MatchAny) && TailMatches("WHERE", "(*)"))
3118 UBC 0 : COMPLETE_WITH(" WITH (");
3119 :
3120 : /*
3121 ECB : * Complete "CREATE PUBLICATION <name> FOR TABLES IN SCHEMA <schema>, ..."
3122 EUB : */
3123 GIC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLES", "IN", "SCHEMA"))
3124 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas
3125 : " AND nspname NOT LIKE E'pg\\\\_%%'",
3126 ECB : "CURRENT_SCHEMA");
3127 GBC 34 : else if (Matches("CREATE", "PUBLICATION", MatchAny, "FOR", "TABLES", "IN", "SCHEMA", MatchAny) && (!ends_with(prev_wd, ',')))
3128 UIC 0 : COMPLETE_WITH("WITH (");
3129 ECB : /* Complete "CREATE PUBLICATION <name> [...] WITH" */
3130 GBC 34 : else if (HeadMatches("CREATE", "PUBLICATION") && TailMatches("WITH", "("))
3131 UIC 0 : COMPLETE_WITH("publish", "publish_via_partition_root");
3132 ECB :
3133 EUB : /* CREATE RULE */
3134 : /* Complete "CREATE [ OR REPLACE ] RULE <sth>" with "AS ON" */
3135 CBC 68 : else if (Matches("CREATE", "RULE", MatchAny) ||
3136 GBC 34 : Matches("CREATE", "OR", "REPLACE", "RULE", MatchAny))
3137 UIC 0 : COMPLETE_WITH("AS ON");
3138 : /* Complete "CREATE [ OR REPLACE ] RULE <sth> AS" with "ON" */
3139 GIC 68 : else if (Matches("CREATE", "RULE", MatchAny, "AS") ||
3140 34 : Matches("CREATE", "OR", "REPLACE", "RULE", MatchAny, "AS"))
3141 UIC 0 : COMPLETE_WITH("ON");
3142 ECB :
3143 EUB : /*
3144 : * Complete "CREATE [ OR REPLACE ] RULE <sth> AS ON" with
3145 ECB : * SELECT|UPDATE|INSERT|DELETE
3146 EUB : */
3147 GIC 68 : else if (Matches("CREATE", "RULE", MatchAny, "AS", "ON") ||
3148 CBC 34 : Matches("CREATE", "OR", "REPLACE", "RULE", MatchAny, "AS", "ON"))
3149 UBC 0 : COMPLETE_WITH("SELECT", "UPDATE", "INSERT", "DELETE");
3150 : /* Complete "AS ON SELECT|UPDATE|INSERT|DELETE" with a "TO" */
3151 CBC 34 : else if (TailMatches("AS", "ON", "SELECT|UPDATE|INSERT|DELETE"))
3152 UBC 0 : COMPLETE_WITH("TO");
3153 : /* Complete "AS ON <sth> TO" with a table name */
3154 CBC 34 : else if (TailMatches("AS", "ON", "SELECT|UPDATE|INSERT|DELETE", "TO"))
3155 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
3156 :
3157 ECB : /* CREATE SEQUENCE --- is allowed inside CREATE SCHEMA, so use TailMatches */
3158 GBC 68 : else if (TailMatches("CREATE", "SEQUENCE", MatchAny) ||
3159 GIC 34 : TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny))
3160 UIC 0 : COMPLETE_WITH("AS", "INCREMENT BY", "MINVALUE", "MAXVALUE", "NO",
3161 ECB : "CACHE", "CYCLE", "OWNED BY", "START WITH");
3162 GBC 68 : else if (TailMatches("CREATE", "SEQUENCE", MatchAny, "AS") ||
3163 GIC 34 : TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny, "AS"))
3164 UIC 0 : COMPLETE_WITH_CS("smallint", "integer", "bigint");
3165 GIC 68 : else if (TailMatches("CREATE", "SEQUENCE", MatchAny, "NO") ||
3166 34 : TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny, "NO"))
3167 UIC 0 : COMPLETE_WITH("MINVALUE", "MAXVALUE", "CYCLE");
3168 ECB :
3169 EUB : /* CREATE SERVER <name> */
3170 GIC 34 : else if (Matches("CREATE", "SERVER", MatchAny))
3171 UIC 0 : COMPLETE_WITH("TYPE", "VERSION", "FOREIGN DATA WRAPPER");
3172 :
3173 : /* CREATE STATISTICS <name> */
3174 GIC 34 : else if (Matches("CREATE", "STATISTICS", MatchAny))
3175 LBC 0 : COMPLETE_WITH("(", "ON");
3176 GBC 34 : else if (Matches("CREATE", "STATISTICS", MatchAny, "("))
3177 UIC 0 : COMPLETE_WITH("ndistinct", "dependencies", "mcv");
3178 GIC 34 : else if (Matches("CREATE", "STATISTICS", MatchAny, "(*)"))
3179 UIC 0 : COMPLETE_WITH("ON");
3180 GIC 34 : else if (HeadMatches("CREATE", "STATISTICS", MatchAny) &&
3181 UIC 0 : TailMatches("FROM"))
3182 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
3183 EUB :
3184 : /* CREATE TABLE --- is allowed inside CREATE SCHEMA, so use TailMatches */
3185 : /* Complete "CREATE TEMP/TEMPORARY" with the possible temp objects */
3186 GIC 34 : else if (TailMatches("CREATE", "TEMP|TEMPORARY"))
3187 UIC 0 : COMPLETE_WITH("SEQUENCE", "TABLE", "VIEW");
3188 : /* Complete "CREATE UNLOGGED" with TABLE or MATVIEW */
3189 CBC 34 : else if (TailMatches("CREATE", "UNLOGGED"))
3190 UBC 0 : COMPLETE_WITH("TABLE", "MATERIALIZED VIEW");
3191 : /* Complete PARTITION BY with RANGE ( or LIST ( or ... */
3192 GIC 34 : else if (TailMatches("PARTITION", "BY"))
3193 UIC 0 : COMPLETE_WITH("RANGE (", "LIST (", "HASH (");
3194 : /* If we have xxx PARTITION OF, provide a list of partitioned tables */
3195 GIC 34 : else if (TailMatches("PARTITION", "OF"))
3196 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables);
3197 EUB : /* Limited completion support for partition bound specification */
3198 GIC 34 : else if (TailMatches("PARTITION", "OF", MatchAny))
3199 UIC 0 : COMPLETE_WITH("FOR VALUES", "DEFAULT");
3200 : /* Complete CREATE TABLE <name> with '(', OF or PARTITION OF */
3201 GIC 68 : else if (TailMatches("CREATE", "TABLE", MatchAny) ||
3202 34 : TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny))
3203 UIC 0 : COMPLETE_WITH("(", "OF", "PARTITION OF");
3204 ECB : /* Complete CREATE TABLE <name> OF with list of composite types */
3205 GBC 68 : else if (TailMatches("CREATE", "TABLE", MatchAny, "OF") ||
3206 GIC 34 : TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "OF"))
3207 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_composite_datatypes);
3208 : /* Complete CREATE TABLE name (...) with supported options */
3209 CBC 68 : else if (TailMatches("CREATE", "TABLE", MatchAny, "(*)") ||
3210 GBC 34 : TailMatches("CREATE", "UNLOGGED", "TABLE", MatchAny, "(*)"))
3211 LBC 0 : COMPLETE_WITH("INHERITS (", "PARTITION BY", "USING", "TABLESPACE", "WITH (");
3212 GBC 34 : else if (TailMatches("CREATE", "TEMP|TEMPORARY", "TABLE", MatchAny, "(*)"))
3213 LBC 0 : COMPLETE_WITH("INHERITS (", "ON COMMIT", "PARTITION BY",
3214 EUB : "TABLESPACE", "WITH (");
3215 ECB : /* Complete CREATE TABLE (...) USING with table access methods */
3216 GBC 68 : else if (TailMatches("CREATE", "TABLE", MatchAny, "(*)", "USING") ||
3217 CBC 34 : TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "(*)", "USING"))
3218 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_table_access_methods);
3219 ECB : /* Complete CREATE TABLE (...) WITH with storage parameters */
3220 GBC 68 : else if (TailMatches("CREATE", "TABLE", MatchAny, "(*)", "WITH", "(") ||
3221 GIC 34 : TailMatches("CREATE", "TEMP|TEMPORARY|UNLOGGED", "TABLE", MatchAny, "(*)", "WITH", "("))
3222 LBC 0 : COMPLETE_WITH_LIST(table_storage_parameters);
3223 EUB : /* Complete CREATE TABLE ON COMMIT with actions */
3224 GIC 34 : else if (TailMatches("CREATE", "TEMP|TEMPORARY", "TABLE", MatchAny, "(*)", "ON", "COMMIT"))
3225 UIC 0 : COMPLETE_WITH("DELETE ROWS", "DROP", "PRESERVE ROWS");
3226 :
3227 : /* CREATE TABLESPACE */
3228 GIC 34 : else if (Matches("CREATE", "TABLESPACE", MatchAny))
3229 LBC 0 : COMPLETE_WITH("OWNER", "LOCATION");
3230 EUB : /* Complete CREATE TABLESPACE name OWNER name with "LOCATION" */
3231 CBC 34 : else if (Matches("CREATE", "TABLESPACE", MatchAny, "OWNER", MatchAny))
3232 UBC 0 : COMPLETE_WITH("LOCATION");
3233 ECB :
3234 EUB : /* CREATE TEXT SEARCH */
3235 GIC 34 : else if (Matches("CREATE", "TEXT", "SEARCH"))
3236 UIC 0 : COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE");
3237 GIC 34 : else if (Matches("CREATE", "TEXT", "SEARCH", "CONFIGURATION|DICTIONARY|PARSER|TEMPLATE", MatchAny))
3238 UIC 0 : COMPLETE_WITH("(");
3239 ECB :
3240 EUB : /* CREATE TRANSFORM */
3241 GIC 68 : else if (Matches("CREATE", "TRANSFORM") ||
3242 34 : Matches("CREATE", "OR", "REPLACE", "TRANSFORM"))
3243 LBC 0 : COMPLETE_WITH("FOR");
3244 GBC 68 : else if (Matches("CREATE", "TRANSFORM", "FOR") ||
3245 GIC 34 : Matches("CREATE", "OR", "REPLACE", "TRANSFORM", "FOR"))
3246 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
3247 GBC 68 : else if (Matches("CREATE", "TRANSFORM", "FOR", MatchAny) ||
3248 GIC 34 : Matches("CREATE", "OR", "REPLACE", "TRANSFORM", "FOR", MatchAny))
3249 UIC 0 : COMPLETE_WITH("LANGUAGE");
3250 GIC 68 : else if (Matches("CREATE", "TRANSFORM", "FOR", MatchAny, "LANGUAGE") ||
3251 CBC 34 : Matches("CREATE", "OR", "REPLACE", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"))
3252 ECB : {
3253 UBC 0 : set_completion_reference(prev2_wd);
3254 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_languages);
3255 ECB : }
3256 :
3257 EUB : /* CREATE SUBSCRIPTION */
3258 GIC 34 : else if (Matches("CREATE", "SUBSCRIPTION", MatchAny))
3259 UIC 0 : COMPLETE_WITH("CONNECTION");
3260 GIC 34 : else if (Matches("CREATE", "SUBSCRIPTION", MatchAny, "CONNECTION", MatchAny))
3261 UIC 0 : COMPLETE_WITH("PUBLICATION");
3262 GIC 34 : else if (Matches("CREATE", "SUBSCRIPTION", MatchAny, "CONNECTION",
3263 ECB : MatchAny, "PUBLICATION"))
3264 : {
3265 EUB : /* complete with nothing here as this refers to remote publications */
3266 : }
3267 CBC 34 : else if (HeadMatches("CREATE", "SUBSCRIPTION") && TailMatches("PUBLICATION", MatchAny))
3268 UBC 0 : COMPLETE_WITH("WITH (");
3269 : /* Complete "CREATE SUBSCRIPTION <name> ... WITH ( <opt>" */
3270 CBC 34 : else if (HeadMatches("CREATE", "SUBSCRIPTION") && TailMatches("WITH", "("))
3271 UBC 0 : COMPLETE_WITH("binary", "connect", "copy_data", "create_slot",
3272 : "disable_on_error", "enabled", "origin",
3273 : "password_required", "run_as_owner", "slot_name",
3274 : "streaming", "synchronous_commit", "two_phase");
3275 ECB :
3276 : /* CREATE TRIGGER --- is allowed inside CREATE SCHEMA, so use TailMatches */
3277 EUB :
3278 : /*
3279 ECB : * Complete CREATE [ OR REPLACE ] TRIGGER <name> with BEFORE|AFTER|INSTEAD
3280 : * OF.
3281 EUB : */
3282 CBC 68 : else if (TailMatches("CREATE", "TRIGGER", MatchAny) ||
3283 34 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny))
3284 UBC 0 : COMPLETE_WITH("BEFORE", "AFTER", "INSTEAD OF");
3285 :
3286 : /*
3287 ECB : * Complete CREATE [ OR REPLACE ] TRIGGER <name> BEFORE,AFTER with an
3288 EUB : * event.
3289 : */
3290 GIC 68 : else if (TailMatches("CREATE", "TRIGGER", MatchAny, "BEFORE|AFTER") ||
3291 CBC 34 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "BEFORE|AFTER"))
3292 UBC 0 : COMPLETE_WITH("INSERT", "DELETE", "UPDATE", "TRUNCATE");
3293 ECB : /* Complete CREATE [ OR REPLACE ] TRIGGER <name> INSTEAD OF with an event */
3294 GBC 68 : else if (TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF") ||
3295 CBC 34 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "INSTEAD", "OF"))
3296 UBC 0 : COMPLETE_WITH("INSERT", "DELETE", "UPDATE");
3297 ECB :
3298 EUB : /*
3299 : * Complete CREATE [ OR REPLACE ] TRIGGER <name> BEFORE,AFTER sth with
3300 : * OR|ON.
3301 : */
3302 GIC 68 : else if (TailMatches("CREATE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny) ||
3303 CBC 68 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny) ||
3304 GBC 68 : TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny) ||
3305 GIC 34 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny))
3306 LBC 0 : COMPLETE_WITH("ON", "OR");
3307 EUB :
3308 : /*
3309 ECB : * Complete CREATE [ OR REPLACE ] TRIGGER <name> BEFORE,AFTER event ON
3310 EUB : * with a list of tables. EXECUTE FUNCTION is the recommended grammar
3311 : * instead of EXECUTE PROCEDURE in version 11 and upwards.
3312 ECB : */
3313 GBC 68 : else if (TailMatches("CREATE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny, "ON") ||
3314 GIC 34 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "BEFORE|AFTER", MatchAny, "ON"))
3315 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
3316 EUB :
3317 : /*
3318 ECB : * Complete CREATE [ OR REPLACE ] TRIGGER ... INSTEAD OF event ON with a
3319 : * list of views.
3320 EUB : */
3321 GIC 68 : else if (TailMatches("CREATE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny, "ON") ||
3322 CBC 34 : TailMatches("CREATE", "OR", "REPLACE", "TRIGGER", MatchAny, "INSTEAD", "OF", MatchAny, "ON"))
3323 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views);
3324 GBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3325 GIC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3326 LBC 0 : TailMatches("ON", MatchAny))
3327 ECB : {
3328 UBC 0 : if (pset.sversion >= 110000)
3329 LBC 0 : COMPLETE_WITH("NOT DEFERRABLE", "DEFERRABLE", "INITIALLY",
3330 EUB : "REFERENCING", "FOR", "WHEN (", "EXECUTE FUNCTION");
3331 : else
3332 UIC 0 : COMPLETE_WITH("NOT DEFERRABLE", "DEFERRABLE", "INITIALLY",
3333 ECB : "REFERENCING", "FOR", "WHEN (", "EXECUTE PROCEDURE");
3334 : }
3335 GBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3336 GIC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3337 LBC 0 : (TailMatches("DEFERRABLE") || TailMatches("INITIALLY", "IMMEDIATE|DEFERRED")))
3338 ECB : {
3339 UBC 0 : if (pset.sversion >= 110000)
3340 UIC 0 : COMPLETE_WITH("REFERENCING", "FOR", "WHEN (", "EXECUTE FUNCTION");
3341 ECB : else
3342 UBC 0 : COMPLETE_WITH("REFERENCING", "FOR", "WHEN (", "EXECUTE PROCEDURE");
3343 : }
3344 GIC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3345 CBC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3346 UBC 0 : TailMatches("REFERENCING"))
3347 UIC 0 : COMPLETE_WITH("OLD TABLE", "NEW TABLE");
3348 CBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3349 GBC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3350 UIC 0 : TailMatches("OLD|NEW", "TABLE"))
3351 0 : COMPLETE_WITH("AS");
3352 CBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3353 GBC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3354 LBC 0 : (TailMatches("REFERENCING", "OLD", "TABLE", "AS", MatchAny) ||
3355 UBC 0 : TailMatches("REFERENCING", "OLD", "TABLE", MatchAny)))
3356 : {
3357 UIC 0 : if (pset.sversion >= 110000)
3358 LBC 0 : COMPLETE_WITH("NEW TABLE", "FOR", "WHEN (", "EXECUTE FUNCTION");
3359 ECB : else
3360 UBC 0 : COMPLETE_WITH("NEW TABLE", "FOR", "WHEN (", "EXECUTE PROCEDURE");
3361 ECB : }
3362 CBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3363 GBC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3364 LBC 0 : (TailMatches("REFERENCING", "NEW", "TABLE", "AS", MatchAny) ||
3365 0 : TailMatches("REFERENCING", "NEW", "TABLE", MatchAny)))
3366 EUB : {
3367 LBC 0 : if (pset.sversion >= 110000)
3368 0 : COMPLETE_WITH("OLD TABLE", "FOR", "WHEN (", "EXECUTE FUNCTION");
3369 : else
3370 UBC 0 : COMPLETE_WITH("OLD TABLE", "FOR", "WHEN (", "EXECUTE PROCEDURE");
3371 EUB : }
3372 GIC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3373 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3374 UIC 0 : (TailMatches("REFERENCING", "OLD|NEW", "TABLE", "AS", MatchAny, "OLD|NEW", "TABLE", "AS", MatchAny) ||
3375 LBC 0 : TailMatches("REFERENCING", "OLD|NEW", "TABLE", MatchAny, "OLD|NEW", "TABLE", "AS", MatchAny) ||
3376 UBC 0 : TailMatches("REFERENCING", "OLD|NEW", "TABLE", "AS", MatchAny, "OLD|NEW", "TABLE", MatchAny) ||
3377 LBC 0 : TailMatches("REFERENCING", "OLD|NEW", "TABLE", MatchAny, "OLD|NEW", "TABLE", MatchAny)))
3378 EUB : {
3379 LBC 0 : if (pset.sversion >= 110000)
3380 UIC 0 : COMPLETE_WITH("FOR", "WHEN (", "EXECUTE FUNCTION");
3381 : else
3382 0 : COMPLETE_WITH("FOR", "WHEN (", "EXECUTE PROCEDURE");
3383 : }
3384 CBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3385 GBC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3386 UIC 0 : TailMatches("FOR"))
3387 LBC 0 : COMPLETE_WITH("EACH", "ROW", "STATEMENT");
3388 GBC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3389 GIC 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3390 UIC 0 : TailMatches("FOR", "EACH"))
3391 0 : COMPLETE_WITH("ROW", "STATEMENT");
3392 GIC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3393 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3394 UIC 0 : (TailMatches("FOR", "EACH", "ROW|STATEMENT") ||
3395 0 : TailMatches("FOR", "ROW|STATEMENT")))
3396 : {
3397 0 : if (pset.sversion >= 110000)
3398 0 : COMPLETE_WITH("WHEN (", "EXECUTE FUNCTION");
3399 ECB : else
3400 LBC 0 : COMPLETE_WITH("WHEN (", "EXECUTE PROCEDURE");
3401 EUB : }
3402 GIC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3403 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3404 UIC 0 : TailMatches("WHEN", "(*)"))
3405 : {
3406 0 : if (pset.sversion >= 110000)
3407 LBC 0 : COMPLETE_WITH("EXECUTE FUNCTION");
3408 ECB : else
3409 UBC 0 : COMPLETE_WITH("EXECUTE PROCEDURE");
3410 : }
3411 ECB :
3412 : /*
3413 EUB : * Complete CREATE [ OR REPLACE ] TRIGGER ... EXECUTE with
3414 : * PROCEDURE|FUNCTION.
3415 : */
3416 GIC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3417 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3418 UIC 0 : TailMatches("EXECUTE"))
3419 ECB : {
3420 LBC 0 : if (pset.sversion >= 110000)
3421 0 : COMPLETE_WITH("FUNCTION");
3422 ECB : else
3423 UBC 0 : COMPLETE_WITH("PROCEDURE");
3424 : }
3425 GIC 68 : else if ((HeadMatches("CREATE", "TRIGGER") ||
3426 34 : HeadMatches("CREATE", "OR", "REPLACE", "TRIGGER")) &&
3427 UIC 0 : TailMatches("EXECUTE", "FUNCTION|PROCEDURE"))
3428 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions);
3429 :
3430 ECB : /* CREATE ROLE,USER,GROUP <name> */
3431 CBC 34 : else if (Matches("CREATE", "ROLE|GROUP|USER", MatchAny) &&
3432 UBC 0 : !TailMatches("USER", "MAPPING"))
3433 UIC 0 : COMPLETE_WITH("ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB",
3434 : "CREATEROLE", "ENCRYPTED PASSWORD", "IN", "INHERIT",
3435 : "LOGIN", "NOBYPASSRLS",
3436 : "NOCREATEDB", "NOCREATEROLE", "NOINHERIT",
3437 : "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD",
3438 ECB : "REPLICATION", "ROLE", "SUPERUSER", "SYSID",
3439 : "VALID UNTIL", "WITH");
3440 EUB :
3441 ECB : /* CREATE ROLE,USER,GROUP <name> WITH */
3442 CBC 34 : else if (Matches("CREATE", "ROLE|GROUP|USER", MatchAny, "WITH"))
3443 EUB : /* Similar to the above, but don't complete "WITH" again. */
3444 UIC 0 : COMPLETE_WITH("ADMIN", "BYPASSRLS", "CONNECTION LIMIT", "CREATEDB",
3445 EUB : "CREATEROLE", "ENCRYPTED PASSWORD", "IN", "INHERIT",
3446 : "LOGIN", "NOBYPASSRLS",
3447 : "NOCREATEDB", "NOCREATEROLE", "NOINHERIT",
3448 : "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", "PASSWORD",
3449 : "REPLICATION", "ROLE", "SUPERUSER", "SYSID",
3450 : "VALID UNTIL");
3451 :
3452 ECB : /* complete CREATE ROLE,USER,GROUP <name> IN with ROLE,GROUP */
3453 CBC 34 : else if (Matches("CREATE", "ROLE|USER|GROUP", MatchAny, "IN"))
3454 UBC 0 : COMPLETE_WITH("GROUP", "ROLE");
3455 :
3456 EUB : /* CREATE TYPE */
3457 GBC 34 : else if (Matches("CREATE", "TYPE", MatchAny))
3458 UIC 0 : COMPLETE_WITH("(", "AS");
3459 GBC 34 : else if (Matches("CREATE", "TYPE", MatchAny, "AS"))
3460 UIC 0 : COMPLETE_WITH("ENUM", "RANGE", "(");
3461 CBC 34 : else if (HeadMatches("CREATE", "TYPE", MatchAny, "AS", "("))
3462 ECB : {
3463 UBC 0 : if (TailMatches("(|*,", MatchAny))
3464 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
3465 LBC 0 : else if (TailMatches("(|*,", MatchAny, MatchAnyExcept("*)")))
3466 0 : COMPLETE_WITH("COLLATE", ",", ")");
3467 EUB : }
3468 GBC 34 : else if (Matches("CREATE", "TYPE", MatchAny, "AS", "ENUM|RANGE"))
3469 LBC 0 : COMPLETE_WITH("(");
3470 CBC 34 : else if (HeadMatches("CREATE", "TYPE", MatchAny, "("))
3471 EUB : {
3472 UBC 0 : if (TailMatches("(|*,"))
3473 UIC 0 : COMPLETE_WITH("INPUT", "OUTPUT", "RECEIVE", "SEND",
3474 EUB : "TYPMOD_IN", "TYPMOD_OUT", "ANALYZE", "SUBSCRIPT",
3475 : "INTERNALLENGTH", "PASSEDBYVALUE", "ALIGNMENT",
3476 : "STORAGE", "LIKE", "CATEGORY", "PREFERRED",
3477 : "DEFAULT", "ELEMENT", "DELIMITER",
3478 : "COLLATABLE");
3479 LBC 0 : else if (TailMatches("(*|*,", MatchAnyExcept("*=")))
3480 0 : COMPLETE_WITH("=");
3481 UBC 0 : else if (TailMatches("=", MatchAnyExcept("*)")))
3482 0 : COMPLETE_WITH(",", ")");
3483 : }
3484 GBC 34 : else if (HeadMatches("CREATE", "TYPE", MatchAny, "AS", "RANGE", "("))
3485 EUB : {
3486 UIC 0 : if (TailMatches("(|*,"))
3487 UBC 0 : COMPLETE_WITH("SUBTYPE", "SUBTYPE_OPCLASS", "COLLATION",
3488 : "CANONICAL", "SUBTYPE_DIFF",
3489 ECB : "MULTIRANGE_TYPE_NAME");
3490 LBC 0 : else if (TailMatches("(*|*,", MatchAnyExcept("*=")))
3491 UBC 0 : COMPLETE_WITH("=");
3492 0 : else if (TailMatches("=", MatchAnyExcept("*)")))
3493 0 : COMPLETE_WITH(",", ")");
3494 EUB : }
3495 :
3496 : /* CREATE VIEW --- is allowed inside CREATE SCHEMA, so use TailMatches */
3497 : /* Complete CREATE [ OR REPLACE ] VIEW <name> with AS */
3498 GIC 68 : else if (TailMatches("CREATE", "VIEW", MatchAny) ||
3499 GBC 34 : TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny))
3500 UIC 0 : COMPLETE_WITH("AS");
3501 ECB : /* Complete "CREATE [ OR REPLACE ] VIEW <sth> AS with "SELECT" */
3502 CBC 68 : else if (TailMatches("CREATE", "VIEW", MatchAny, "AS") ||
3503 GBC 34 : TailMatches("CREATE", "OR", "REPLACE", "VIEW", MatchAny, "AS"))
3504 UBC 0 : COMPLETE_WITH("SELECT");
3505 ECB :
3506 : /* CREATE MATERIALIZED VIEW */
3507 GBC 34 : else if (Matches("CREATE", "MATERIALIZED"))
3508 UBC 0 : COMPLETE_WITH("VIEW");
3509 ECB : /* Complete CREATE MATERIALIZED VIEW <name> with AS */
3510 CBC 34 : else if (Matches("CREATE", "MATERIALIZED", "VIEW", MatchAny))
3511 UBC 0 : COMPLETE_WITH("AS");
3512 EUB : /* Complete "CREATE MATERIALIZED VIEW <sth> AS with "SELECT" */
3513 GIC 34 : else if (Matches("CREATE", "MATERIALIZED", "VIEW", MatchAny, "AS"))
3514 UBC 0 : COMPLETE_WITH("SELECT");
3515 EUB :
3516 : /* CREATE EVENT TRIGGER */
3517 GBC 34 : else if (Matches("CREATE", "EVENT"))
3518 UIC 0 : COMPLETE_WITH("TRIGGER");
3519 ECB : /* Complete CREATE EVENT TRIGGER <name> with ON */
3520 CBC 34 : else if (Matches("CREATE", "EVENT", "TRIGGER", MatchAny))
3521 UBC 0 : COMPLETE_WITH("ON");
3522 : /* Complete CREATE EVENT TRIGGER <name> ON with event_type */
3523 GBC 34 : else if (Matches("CREATE", "EVENT", "TRIGGER", MatchAny, "ON"))
3524 UBC 0 : COMPLETE_WITH("ddl_command_start", "ddl_command_end", "sql_drop",
3525 : "table_rewrite");
3526 EUB :
3527 : /*
3528 : * Complete CREATE EVENT TRIGGER <name> ON <event_type>. EXECUTE FUNCTION
3529 : * is the recommended grammar instead of EXECUTE PROCEDURE in version 11
3530 : * and upwards.
3531 : */
3532 GIC 34 : else if (Matches("CREATE", "EVENT", "TRIGGER", MatchAny, "ON", MatchAny))
3533 ECB : {
3534 LBC 0 : if (pset.sversion >= 110000)
3535 UBC 0 : COMPLETE_WITH("WHEN TAG IN (", "EXECUTE FUNCTION");
3536 : else
3537 0 : COMPLETE_WITH("WHEN TAG IN (", "EXECUTE PROCEDURE");
3538 EUB : }
3539 GIC 34 : else if (HeadMatches("CREATE", "EVENT", "TRIGGER") &&
3540 UBC 0 : TailMatches("WHEN|AND", MatchAny, "IN", "(*)"))
3541 : {
3542 LBC 0 : if (pset.sversion >= 110000)
3543 0 : COMPLETE_WITH("EXECUTE FUNCTION");
3544 EUB : else
3545 UBC 0 : COMPLETE_WITH("EXECUTE PROCEDURE");
3546 : }
3547 GIC 34 : else if (HeadMatches("CREATE", "EVENT", "TRIGGER") &&
3548 LBC 0 : TailMatches("EXECUTE", "FUNCTION|PROCEDURE"))
3549 UBC 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions);
3550 EUB :
3551 : /* DEALLOCATE */
3552 GIC 34 : else if (Matches("DEALLOCATE"))
3553 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_prepared_statements,
3554 : "ALL");
3555 :
3556 : /* DECLARE */
3557 :
3558 : /*
3559 ECB : * Complete DECLARE <name> with one of BINARY, ASENSITIVE, INSENSITIVE,
3560 : * SCROLL, NO SCROLL, and CURSOR.
3561 EUB : */
3562 GIC 34 : else if (Matches("DECLARE", MatchAny))
3563 UIC 0 : COMPLETE_WITH("BINARY", "ASENSITIVE", "INSENSITIVE", "SCROLL", "NO SCROLL",
3564 : "CURSOR");
3565 :
3566 : /*
3567 : * Complete DECLARE ... <option> with other options. The PostgreSQL parser
3568 : * allows DECLARE options to be specified in any order. But the
3569 : * tab-completion follows the ordering of them that the SQL standard
3570 ECB : * provides, like the syntax of DECLARE command in the documentation
3571 EUB : * indicates.
3572 : */
3573 GIC 34 : else if (HeadMatches("DECLARE") && TailMatches("BINARY"))
3574 LBC 0 : COMPLETE_WITH("ASENSITIVE", "INSENSITIVE", "SCROLL", "NO SCROLL", "CURSOR");
3575 GBC 34 : else if (HeadMatches("DECLARE") && TailMatches("ASENSITIVE|INSENSITIVE"))
3576 LBC 0 : COMPLETE_WITH("SCROLL", "NO SCROLL", "CURSOR");
3577 GBC 34 : else if (HeadMatches("DECLARE") && TailMatches("SCROLL"))
3578 LBC 0 : COMPLETE_WITH("CURSOR");
3579 : /* Complete DECLARE ... [options] NO with SCROLL */
3580 GBC 34 : else if (HeadMatches("DECLARE") && TailMatches("NO"))
3581 UBC 0 : COMPLETE_WITH("SCROLL");
3582 EUB :
3583 : /*
3584 : * Complete DECLARE ... CURSOR with one of WITH HOLD, WITHOUT HOLD, and
3585 ECB : * FOR
3586 EUB : */
3587 CBC 34 : else if (HeadMatches("DECLARE") && TailMatches("CURSOR"))
3588 UIC 0 : COMPLETE_WITH("WITH HOLD", "WITHOUT HOLD", "FOR");
3589 EUB : /* Complete DECLARE ... CURSOR WITH|WITHOUT with HOLD */
3590 GBC 34 : else if (HeadMatches("DECLARE") && TailMatches("CURSOR", "WITH|WITHOUT"))
3591 UIC 0 : COMPLETE_WITH("HOLD");
3592 : /* Complete DECLARE ... CURSOR WITH|WITHOUT HOLD with FOR */
3593 GIC 34 : else if (HeadMatches("DECLARE") && TailMatches("CURSOR", "WITH|WITHOUT", "HOLD"))
3594 UIC 0 : COMPLETE_WITH("FOR");
3595 :
3596 EUB : /* DELETE --- can be inside EXPLAIN, RULE, etc */
3597 : /* Complete DELETE with "FROM" */
3598 GBC 34 : else if (Matches("DELETE"))
3599 UBC 0 : COMPLETE_WITH("FROM");
3600 : /* Complete DELETE FROM with a list of tables */
3601 CBC 34 : else if (TailMatches("DELETE", "FROM"))
3602 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables);
3603 EUB : /* Complete DELETE FROM <table> */
3604 GBC 34 : else if (TailMatches("DELETE", "FROM", MatchAny))
3605 UIC 0 : COMPLETE_WITH("USING", "WHERE");
3606 : /* XXX: implement tab completion for DELETE ... USING */
3607 EUB :
3608 : /* DISCARD */
3609 GBC 34 : else if (Matches("DISCARD"))
3610 UBC 0 : COMPLETE_WITH("ALL", "PLANS", "SEQUENCES", "TEMP");
3611 :
3612 : /* DO */
3613 GIC 34 : else if (Matches("DO"))
3614 UIC 0 : COMPLETE_WITH("LANGUAGE");
3615 ECB :
3616 : /* DROP */
3617 EUB : /* Complete DROP object with CASCADE / RESTRICT */
3618 GIC 34 : else if (Matches("DROP",
3619 ECB : "COLLATION|CONVERSION|DOMAIN|EXTENSION|LANGUAGE|PUBLICATION|SCHEMA|SEQUENCE|SERVER|SUBSCRIPTION|STATISTICS|TABLE|TYPE|VIEW",
3620 CBC 33 : MatchAny) ||
3621 GBC 66 : Matches("DROP", "ACCESS", "METHOD", MatchAny) ||
3622 GIC 33 : (Matches("DROP", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny, MatchAny) &&
3623 33 : ends_with(prev_wd, ')')) ||
3624 CBC 66 : Matches("DROP", "EVENT", "TRIGGER", MatchAny) ||
3625 GBC 66 : Matches("DROP", "FOREIGN", "DATA", "WRAPPER", MatchAny) ||
3626 GIC 66 : Matches("DROP", "FOREIGN", "TABLE", MatchAny) ||
3627 CBC 33 : Matches("DROP", "TEXT", "SEARCH", "CONFIGURATION|DICTIONARY|PARSER|TEMPLATE", MatchAny))
3628 GBC 1 : COMPLETE_WITH("CASCADE", "RESTRICT");
3629 :
3630 ECB : /* help completing some of the variants */
3631 GBC 33 : else if (Matches("DROP", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny))
3632 UIC 0 : COMPLETE_WITH("(");
3633 GIC 33 : else if (Matches("DROP", "AGGREGATE|FUNCTION|PROCEDURE|ROUTINE", MatchAny, "("))
3634 LBC 0 : COMPLETE_WITH_FUNCTION_ARG(prev2_wd);
3635 GBC 33 : else if (Matches("DROP", "FOREIGN"))
3636 UIC 0 : COMPLETE_WITH("DATA WRAPPER", "TABLE");
3637 CBC 33 : else if (Matches("DROP", "DATABASE", MatchAny))
3638 UBC 0 : COMPLETE_WITH("WITH (");
3639 GIC 33 : else if (HeadMatches("DROP", "DATABASE") && (ends_with(prev_wd, '(')))
3640 LBC 0 : COMPLETE_WITH("FORCE");
3641 EUB :
3642 : /* DROP INDEX */
3643 GIC 33 : else if (Matches("DROP", "INDEX"))
3644 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes,
3645 : "CONCURRENTLY");
3646 GIC 33 : else if (Matches("DROP", "INDEX", "CONCURRENTLY"))
3647 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes);
3648 GIC 33 : else if (Matches("DROP", "INDEX", MatchAny))
3649 LBC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3650 GIC 33 : else if (Matches("DROP", "INDEX", "CONCURRENTLY", MatchAny))
3651 UBC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3652 EUB :
3653 : /* DROP MATERIALIZED VIEW */
3654 GBC 33 : else if (Matches("DROP", "MATERIALIZED"))
3655 UIC 0 : COMPLETE_WITH("VIEW");
3656 CBC 33 : else if (Matches("DROP", "MATERIALIZED", "VIEW"))
3657 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews);
3658 GIC 33 : else if (Matches("DROP", "MATERIALIZED", "VIEW", MatchAny))
3659 UBC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3660 EUB :
3661 : /* DROP OWNED BY */
3662 GBC 33 : else if (Matches("DROP", "OWNED"))
3663 UIC 0 : COMPLETE_WITH("BY");
3664 CBC 33 : else if (Matches("DROP", "OWNED", "BY"))
3665 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
3666 GBC 33 : else if (Matches("DROP", "OWNED", "BY", MatchAny))
3667 UIC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3668 :
3669 ECB : /* DROP TEXT SEARCH */
3670 GBC 33 : else if (Matches("DROP", "TEXT", "SEARCH"))
3671 UIC 0 : COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE");
3672 :
3673 : /* DROP TRIGGER */
3674 GIC 33 : else if (Matches("DROP", "TRIGGER", MatchAny))
3675 UIC 0 : COMPLETE_WITH("ON");
3676 GIC 33 : else if (Matches("DROP", "TRIGGER", MatchAny, "ON"))
3677 : {
3678 UIC 0 : set_completion_reference(prev2_wd);
3679 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_trigger);
3680 EUB : }
3681 GIC 33 : else if (Matches("DROP", "TRIGGER", MatchAny, "ON", MatchAny))
3682 UIC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3683 :
3684 : /* DROP ACCESS METHOD */
3685 GIC 33 : else if (Matches("DROP", "ACCESS"))
3686 UIC 0 : COMPLETE_WITH("METHOD");
3687 GIC 33 : else if (Matches("DROP", "ACCESS", "METHOD"))
3688 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_access_methods);
3689 :
3690 ECB : /* DROP EVENT TRIGGER */
3691 GBC 33 : else if (Matches("DROP", "EVENT"))
3692 LBC 0 : COMPLETE_WITH("TRIGGER");
3693 GBC 33 : else if (Matches("DROP", "EVENT", "TRIGGER"))
3694 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
3695 EUB :
3696 : /* DROP POLICY <name> */
3697 CBC 33 : else if (Matches("DROP", "POLICY"))
3698 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_policies);
3699 : /* DROP POLICY <name> ON */
3700 GIC 33 : else if (Matches("DROP", "POLICY", MatchAny))
3701 UIC 0 : COMPLETE_WITH("ON");
3702 : /* DROP POLICY <name> ON <table> */
3703 GIC 33 : else if (Matches("DROP", "POLICY", MatchAny, "ON"))
3704 ECB : {
3705 UBC 0 : set_completion_reference(prev2_wd);
3706 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_policy);
3707 ECB : }
3708 GBC 33 : else if (Matches("DROP", "POLICY", MatchAny, "ON", MatchAny))
3709 UIC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3710 ECB :
3711 EUB : /* DROP RULE */
3712 GIC 33 : else if (Matches("DROP", "RULE", MatchAny))
3713 UIC 0 : COMPLETE_WITH("ON");
3714 GIC 33 : else if (Matches("DROP", "RULE", MatchAny, "ON"))
3715 ECB : {
3716 UBC 0 : set_completion_reference(prev2_wd);
3717 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables_for_rule);
3718 ECB : }
3719 GBC 33 : else if (Matches("DROP", "RULE", MatchAny, "ON", MatchAny))
3720 UIC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3721 ECB :
3722 EUB : /* DROP TRANSFORM */
3723 GIC 33 : else if (Matches("DROP", "TRANSFORM"))
3724 UIC 0 : COMPLETE_WITH("FOR");
3725 GIC 33 : else if (Matches("DROP", "TRANSFORM", "FOR"))
3726 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
3727 GBC 33 : else if (Matches("DROP", "TRANSFORM", "FOR", MatchAny))
3728 UIC 0 : COMPLETE_WITH("LANGUAGE");
3729 GIC 33 : else if (Matches("DROP", "TRANSFORM", "FOR", MatchAny, "LANGUAGE"))
3730 ECB : {
3731 UBC 0 : set_completion_reference(prev2_wd);
3732 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_languages);
3733 : }
3734 GIC 33 : else if (Matches("DROP", "TRANSFORM", "FOR", MatchAny, "LANGUAGE", MatchAny))
3735 LBC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
3736 :
3737 ECB : /* EXECUTE */
3738 CBC 33 : else if (Matches("EXECUTE"))
3739 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_prepared_statements);
3740 ECB :
3741 : /*
3742 : * EXPLAIN [ ( option [, ...] ) ] statement
3743 : * EXPLAIN [ ANALYZE ] [ VERBOSE ] statement
3744 : */
3745 CBC 33 : else if (Matches("EXPLAIN"))
3746 UIC 0 : COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE",
3747 : "MERGE INTO", "EXECUTE", "ANALYZE", "VERBOSE");
3748 CBC 33 : else if (HeadMatches("EXPLAIN", "(*") &&
3749 UBC 0 : !HeadMatches("EXPLAIN", "(*)"))
3750 ECB : {
3751 EUB : /*
3752 ECB : * This fires if we're in an unfinished parenthesized option list.
3753 EUB : * get_previous_words treats a completed parenthesized option list as
3754 ECB : * one word, so the above test is correct.
3755 EUB : */
3756 LBC 0 : if (ends_with(prev_wd, '(') || ends_with(prev_wd, ','))
3757 UNC 0 : COMPLETE_WITH("ANALYZE", "VERBOSE", "COSTS", "SETTINGS", "GENERIC_PLAN",
3758 : "BUFFERS", "WAL", "TIMING", "SUMMARY", "FORMAT");
3759 0 : else if (TailMatches("ANALYZE|VERBOSE|COSTS|SETTINGS|GENERIC_PLAN|BUFFERS|WAL|TIMING|SUMMARY"))
3760 LBC 0 : COMPLETE_WITH("ON", "OFF");
3761 UBC 0 : else if (TailMatches("FORMAT"))
3762 UIC 0 : COMPLETE_WITH("TEXT", "XML", "JSON", "YAML");
3763 ECB : }
3764 GBC 33 : else if (Matches("EXPLAIN", "ANALYZE"))
3765 LBC 0 : COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE",
3766 EUB : "MERGE INTO", "EXECUTE", "VERBOSE");
3767 CBC 66 : else if (Matches("EXPLAIN", "(*)") ||
3768 GBC 66 : Matches("EXPLAIN", "VERBOSE") ||
3769 GIC 33 : Matches("EXPLAIN", "ANALYZE", "VERBOSE"))
3770 UIC 0 : COMPLETE_WITH("SELECT", "INSERT INTO", "DELETE FROM", "UPDATE", "DECLARE",
3771 ECB : "MERGE INTO", "EXECUTE");
3772 EUB :
3773 ECB : /* FETCH && MOVE */
3774 EUB :
3775 ECB : /*
3776 EUB : * Complete FETCH with one of ABSOLUTE, BACKWARD, FORWARD, RELATIVE, ALL,
3777 : * NEXT, PRIOR, FIRST, LAST, FROM, IN, and a list of cursors
3778 : */
3779 CBC 33 : else if (Matches("FETCH|MOVE"))
3780 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors,
3781 ECB : "ABSOLUTE",
3782 EUB : "BACKWARD",
3783 ECB : "FORWARD",
3784 EUB : "RELATIVE",
3785 : "ALL",
3786 : "NEXT",
3787 ECB : "PRIOR",
3788 EUB : "FIRST",
3789 : "LAST",
3790 : "FROM",
3791 ECB : "IN");
3792 EUB :
3793 ECB : /*
3794 : * Complete FETCH BACKWARD or FORWARD with one of ALL, FROM, IN, and a
3795 EUB : * list of cursors
3796 : */
3797 GIC 33 : else if (Matches("FETCH|MOVE", "BACKWARD|FORWARD"))
3798 LBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors,
3799 EUB : "ALL",
3800 : "FROM",
3801 : "IN");
3802 ECB :
3803 EUB : /*
3804 ECB : * Complete FETCH <direction> with "FROM" or "IN". These are equivalent,
3805 EUB : * but we may as well tab-complete both: perhaps some users prefer one
3806 : * variant or the other.
3807 : */
3808 CBC 33 : else if (Matches("FETCH|MOVE", "ABSOLUTE|BACKWARD|FORWARD|RELATIVE",
3809 GBC 33 : MatchAnyExcept("FROM|IN")) ||
3810 CBC 33 : Matches("FETCH|MOVE", "ALL|NEXT|PRIOR|FIRST|LAST"))
3811 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_cursors,
3812 : "FROM",
3813 : "IN");
3814 ECB : /* Complete FETCH <direction> "FROM" or "IN" with a list of cursors */
3815 GBC 33 : else if (HeadMatches("FETCH|MOVE") &&
3816 UIC 0 : TailMatches("FROM|IN"))
3817 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_cursors);
3818 EUB :
3819 : /* FOREIGN DATA WRAPPER */
3820 ECB : /* applies in ALTER/DROP FDW and in CREATE SERVER */
3821 GIC 33 : else if (TailMatches("FOREIGN", "DATA", "WRAPPER") &&
3822 UBC 0 : !TailMatches("CREATE", MatchAny, MatchAny, MatchAny))
3823 0 : COMPLETE_WITH_QUERY(Query_for_list_of_fdws);
3824 : /* applies in CREATE SERVER */
3825 CBC 33 : else if (TailMatches("FOREIGN", "DATA", "WRAPPER", MatchAny) &&
3826 UBC 0 : HeadMatches("CREATE", "SERVER"))
3827 UIC 0 : COMPLETE_WITH("OPTIONS");
3828 :
3829 ECB : /* FOREIGN TABLE */
3830 GBC 33 : else if (TailMatches("FOREIGN", "TABLE") &&
3831 LBC 0 : !TailMatches("CREATE", MatchAny, MatchAny))
3832 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables);
3833 EUB :
3834 : /* FOREIGN SERVER */
3835 GIC 33 : else if (TailMatches("FOREIGN", "SERVER"))
3836 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_servers);
3837 EUB :
3838 : /*
3839 : * GRANT and REVOKE are allowed inside CREATE SCHEMA and
3840 ECB : * ALTER DEFAULT PRIVILEGES, so use TailMatches
3841 EUB : */
3842 ECB : /* Complete GRANT/REVOKE with a list of roles and privileges */
3843 GBC 66 : else if (TailMatches("GRANT|REVOKE") ||
3844 GNC 33 : TailMatches("REVOKE", "ADMIN|GRANT|INHERIT|SET", "OPTION", "FOR"))
3845 EUB : {
3846 ECB : /*
3847 : * With ALTER DEFAULT PRIVILEGES, restrict completion to grantable
3848 EUB : * privileges (can't grant roles)
3849 : */
3850 UIC 0 : if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES"))
3851 LBC 0 : COMPLETE_WITH("SELECT", "INSERT", "UPDATE",
3852 EUB : "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER",
3853 : "CREATE", "EXECUTE", "USAGE", "MAINTAIN", "ALL");
3854 UNC 0 : else if (TailMatches("GRANT"))
3855 LBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
3856 : Privilege_options_of_grant_and_revoke);
3857 UNC 0 : else if (TailMatches("REVOKE"))
3858 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
3859 : Privilege_options_of_grant_and_revoke,
3860 : "GRANT OPTION FOR",
3861 : "ADMIN OPTION FOR",
3862 : "INHERIT OPTION FOR",
3863 : "SET OPTION FOR");
3864 0 : else if (TailMatches("REVOKE", "GRANT", "OPTION", "FOR"))
3865 0 : COMPLETE_WITH(Privilege_options_of_grant_and_revoke);
3866 0 : else if (TailMatches("REVOKE", "ADMIN|INHERIT|SET", "OPTION", "FOR"))
3867 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
3868 : }
3869 EUB :
3870 GBC 66 : else if (TailMatches("GRANT|REVOKE", "ALTER") ||
3871 GIC 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", "ALTER"))
3872 LBC 0 : COMPLETE_WITH("SYSTEM");
3873 EUB :
3874 GNC 33 : else if (TailMatches("REVOKE", "SET"))
3875 UNC 0 : COMPLETE_WITH("ON PARAMETER", "OPTION FOR");
3876 GNC 66 : else if (TailMatches("GRANT", "SET") ||
3877 CBC 66 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", "SET") ||
3878 66 : TailMatches("GRANT|REVOKE", "ALTER", "SYSTEM") ||
3879 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", "ALTER", "SYSTEM"))
3880 UBC 0 : COMPLETE_WITH("ON PARAMETER");
3881 :
3882 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", "PARAMETER") ||
3883 66 : TailMatches("GRANT|REVOKE", MatchAny, MatchAny, "ON", "PARAMETER") ||
3884 66 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "PARAMETER") ||
3885 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, MatchAny, "ON", "PARAMETER"))
3886 UIC 0 : COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_alter_system_set_vars);
3887 :
3888 GIC 66 : else if (TailMatches("GRANT", MatchAny, "ON", "PARAMETER", MatchAny) ||
3889 CBC 33 : TailMatches("GRANT", MatchAny, MatchAny, "ON", "PARAMETER", MatchAny))
3890 UBC 0 : COMPLETE_WITH("TO");
3891 :
3892 GIC 66 : else if (TailMatches("REVOKE", MatchAny, "ON", "PARAMETER", MatchAny) ||
3893 66 : TailMatches("REVOKE", MatchAny, MatchAny, "ON", "PARAMETER", MatchAny) ||
3894 66 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "PARAMETER", MatchAny) ||
3895 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, MatchAny, "ON", "PARAMETER", MatchAny))
3896 UIC 0 : COMPLETE_WITH("FROM");
3897 :
3898 : /*
3899 : * Complete GRANT/REVOKE <privilege> with "ON", GRANT/REVOKE <role> with
3900 : * TO/FROM
3901 : */
3902 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny) ||
3903 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny))
3904 : {
3905 UIC 0 : if (TailMatches("SELECT|INSERT|UPDATE|DELETE|TRUNCATE|REFERENCES|TRIGGER|CREATE|CONNECT|TEMPORARY|TEMP|EXECUTE|USAGE|ALL"))
3906 0 : COMPLETE_WITH("ON");
3907 LBC 0 : else if (TailMatches("GRANT", MatchAny))
3908 UBC 0 : COMPLETE_WITH("TO");
3909 : else
3910 UIC 0 : COMPLETE_WITH("FROM");
3911 : }
3912 :
3913 : /*
3914 : * Complete GRANT/REVOKE <sth> ON with a list of appropriate relations.
3915 : *
3916 : * Note: GRANT/REVOKE can get quite complex; tab-completion as implemented
3917 : * here will only work if the privilege list contains exactly one
3918 ECB : * privilege.
3919 : */
3920 CBC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON") ||
3921 GBC 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON"))
3922 : {
3923 : /*
3924 : * With ALTER DEFAULT PRIVILEGES, restrict completion to the kinds of
3925 ECB : * objects supported.
3926 EUB : */
3927 UBC 0 : if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES"))
3928 UIC 0 : COMPLETE_WITH("TABLES", "SEQUENCES", "FUNCTIONS", "PROCEDURES", "ROUTINES", "TYPES", "SCHEMAS");
3929 : else
3930 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_grantables,
3931 ECB : "ALL FUNCTIONS IN SCHEMA",
3932 EUB : "ALL PROCEDURES IN SCHEMA",
3933 : "ALL ROUTINES IN SCHEMA",
3934 : "ALL SEQUENCES IN SCHEMA",
3935 ECB : "ALL TABLES IN SCHEMA",
3936 EUB : "DATABASE",
3937 : "DOMAIN",
3938 : "FOREIGN DATA WRAPPER",
3939 : "FOREIGN SERVER",
3940 ECB : "FUNCTION",
3941 EUB : "LANGUAGE",
3942 : "LARGE OBJECT",
3943 : "PARAMETER",
3944 : "PROCEDURE",
3945 ECB : "ROUTINE",
3946 EUB : "SCHEMA",
3947 : "SEQUENCE",
3948 : "TABLE",
3949 : "TABLESPACE",
3950 : "TYPE");
3951 : }
3952 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", "ALL") ||
3953 CBC 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "ALL"))
3954 LBC 0 : COMPLETE_WITH("FUNCTIONS IN SCHEMA",
3955 : "PROCEDURES IN SCHEMA",
3956 : "ROUTINES IN SCHEMA",
3957 : "SEQUENCES IN SCHEMA",
3958 : "TABLES IN SCHEMA");
3959 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", "FOREIGN") ||
3960 GBC 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "FOREIGN"))
3961 UBC 0 : COMPLETE_WITH("DATA WRAPPER", "SERVER");
3962 :
3963 : /*
3964 EUB : * Complete "GRANT/REVOKE * ON DATABASE/DOMAIN/..." with a list of
3965 : * appropriate objects.
3966 : *
3967 : * Complete "GRANT/REVOKE * ON *" with "TO/FROM".
3968 : */
3969 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", MatchAny) ||
3970 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", MatchAny))
3971 : {
3972 UIC 0 : if (TailMatches("DATABASE"))
3973 0 : COMPLETE_WITH_QUERY(Query_for_list_of_databases);
3974 UBC 0 : else if (TailMatches("DOMAIN"))
3975 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains);
3976 0 : else if (TailMatches("FUNCTION"))
3977 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions);
3978 UIC 0 : else if (TailMatches("LANGUAGE"))
3979 0 : COMPLETE_WITH_QUERY(Query_for_list_of_languages);
3980 LBC 0 : else if (TailMatches("PROCEDURE"))
3981 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures);
3982 UBC 0 : else if (TailMatches("ROUTINE"))
3983 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines);
3984 LBC 0 : else if (TailMatches("SCHEMA"))
3985 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
3986 LBC 0 : else if (TailMatches("SEQUENCE"))
3987 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences);
3988 0 : else if (TailMatches("TABLE"))
3989 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_grantables);
3990 UBC 0 : else if (TailMatches("TABLESPACE"))
3991 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
3992 LBC 0 : else if (TailMatches("TYPE"))
3993 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
3994 0 : else if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny))
3995 0 : COMPLETE_WITH("TO");
3996 EUB : else
3997 UIC 0 : COMPLETE_WITH("FROM");
3998 ECB : }
3999 :
4000 EUB : /*
4001 : * Complete "GRANT/REVOKE ... TO/FROM" with username, PUBLIC,
4002 ECB : * CURRENT_ROLE, CURRENT_USER, or SESSION_USER.
4003 : */
4004 CBC 66 : else if ((HeadMatches("GRANT") && TailMatches("TO")) ||
4005 33 : (HeadMatches("REVOKE") && TailMatches("FROM")))
4006 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
4007 : Keywords_for_list_of_grant_roles);
4008 :
4009 : /*
4010 : * Offer grant options after that.
4011 : */
4012 CBC 33 : else if (HeadMatches("GRANT") && TailMatches("TO", MatchAny))
4013 UNC 0 : COMPLETE_WITH("WITH ADMIN",
4014 : "WITH INHERIT",
4015 : "WITH SET",
4016 : "WITH GRANT OPTION",
4017 EUB : "GRANTED BY");
4018 GBC 33 : else if (HeadMatches("GRANT") && TailMatches("TO", MatchAny, "WITH"))
4019 UNC 0 : COMPLETE_WITH("ADMIN",
4020 : "INHERIT",
4021 : "SET",
4022 EUB : "GRANT OPTION");
4023 GNC 33 : else if (HeadMatches("GRANT") &&
4024 UNC 0 : (TailMatches("TO", MatchAny, "WITH", "ADMIN|INHERIT|SET")))
4025 0 : COMPLETE_WITH("OPTION", "TRUE", "FALSE");
4026 GIC 33 : else if (HeadMatches("GRANT") && TailMatches("TO", MatchAny, "WITH", MatchAny, "OPTION"))
4027 UBC 0 : COMPLETE_WITH("GRANTED BY");
4028 GIC 33 : else if (HeadMatches("GRANT") && TailMatches("TO", MatchAny, "WITH", MatchAny, "OPTION", "GRANTED", "BY"))
4029 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
4030 : Keywords_for_list_of_grant_roles);
4031 : /* Complete "ALTER DEFAULT PRIVILEGES ... GRANT/REVOKE ... TO/FROM */
4032 GIC 33 : else if (HeadMatches("ALTER", "DEFAULT", "PRIVILEGES") && TailMatches("TO|FROM"))
4033 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
4034 : Keywords_for_list_of_grant_roles);
4035 : /* Complete "GRANT/REVOKE ... ON * *" with TO/FROM */
4036 GIC 33 : else if (HeadMatches("GRANT") && TailMatches("ON", MatchAny, MatchAny))
4037 LBC 0 : COMPLETE_WITH("TO");
4038 CBC 33 : else if (HeadMatches("REVOKE") && TailMatches("ON", MatchAny, MatchAny))
4039 UIC 0 : COMPLETE_WITH("FROM");
4040 :
4041 : /* Complete "GRANT/REVOKE * ON ALL * IN SCHEMA *" with TO/FROM */
4042 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", "ALL", MatchAny, "IN", "SCHEMA", MatchAny) ||
4043 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "ALL", MatchAny, "IN", "SCHEMA", MatchAny))
4044 EUB : {
4045 UBC 0 : if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny))
4046 UIC 0 : COMPLETE_WITH("TO");
4047 EUB : else
4048 UIC 0 : COMPLETE_WITH("FROM");
4049 : }
4050 :
4051 : /* Complete "GRANT/REVOKE * ON FOREIGN DATA WRAPPER *" with TO/FROM */
4052 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", "FOREIGN", "DATA", "WRAPPER", MatchAny) ||
4053 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "FOREIGN", "DATA", "WRAPPER", MatchAny))
4054 : {
4055 UIC 0 : if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny, MatchAny))
4056 0 : COMPLETE_WITH("TO");
4057 : else
4058 0 : COMPLETE_WITH("FROM");
4059 : }
4060 :
4061 : /* Complete "GRANT/REVOKE * ON FOREIGN SERVER *" with TO/FROM */
4062 GIC 66 : else if (TailMatches("GRANT|REVOKE", MatchAny, "ON", "FOREIGN", "SERVER", MatchAny) ||
4063 33 : TailMatches("REVOKE", "GRANT", "OPTION", "FOR", MatchAny, "ON", "FOREIGN", "SERVER", MatchAny))
4064 : {
4065 UIC 0 : if (TailMatches("GRANT", MatchAny, MatchAny, MatchAny, MatchAny, MatchAny))
4066 0 : COMPLETE_WITH("TO");
4067 : else
4068 0 : COMPLETE_WITH("FROM");
4069 ECB : }
4070 :
4071 EUB : /* GROUP BY */
4072 GIC 33 : else if (TailMatches("FROM", MatchAny, "GROUP"))
4073 UIC 0 : COMPLETE_WITH("BY");
4074 :
4075 : /* IMPORT FOREIGN SCHEMA */
4076 CBC 33 : else if (Matches("IMPORT"))
4077 LBC 0 : COMPLETE_WITH("FOREIGN SCHEMA");
4078 GBC 33 : else if (Matches("IMPORT", "FOREIGN"))
4079 UIC 0 : COMPLETE_WITH("SCHEMA");
4080 GIC 33 : else if (Matches("IMPORT", "FOREIGN", "SCHEMA", MatchAny))
4081 UIC 0 : COMPLETE_WITH("EXCEPT (", "FROM SERVER", "LIMIT TO (");
4082 GIC 66 : else if (TailMatches("LIMIT", "TO", "(*)") ||
4083 33 : TailMatches("EXCEPT", "(*)"))
4084 UIC 0 : COMPLETE_WITH("FROM SERVER");
4085 GIC 33 : else if (TailMatches("FROM", "SERVER", MatchAny))
4086 LBC 0 : COMPLETE_WITH("INTO");
4087 CBC 33 : else if (TailMatches("FROM", "SERVER", MatchAny, "INTO"))
4088 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
4089 GBC 33 : else if (TailMatches("FROM", "SERVER", MatchAny, "INTO", MatchAny))
4090 UBC 0 : COMPLETE_WITH("OPTIONS (");
4091 EUB :
4092 : /* INSERT --- can be inside EXPLAIN, RULE, etc */
4093 : /* Complete NOT MATCHED THEN INSERT */
4094 GBC 33 : else if (TailMatches("NOT", "MATCHED", "THEN", "INSERT"))
4095 UBC 0 : COMPLETE_WITH("VALUES", "(");
4096 EUB : /* Complete INSERT with "INTO" */
4097 GBC 33 : else if (TailMatches("INSERT"))
4098 UBC 0 : COMPLETE_WITH("INTO");
4099 EUB : /* Complete INSERT INTO with table names */
4100 GBC 33 : else if (TailMatches("INSERT", "INTO"))
4101 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables);
4102 EUB : /* Complete "INSERT INTO <table> (" with attribute names */
4103 GBC 33 : else if (TailMatches("INSERT", "INTO", MatchAny, "("))
4104 UBC 0 : COMPLETE_WITH_ATTR(prev2_wd);
4105 EUB :
4106 : /*
4107 : * Complete INSERT INTO <table> with "(" or "VALUES" or "SELECT" or
4108 : * "TABLE" or "DEFAULT VALUES" or "OVERRIDING"
4109 : */
4110 GBC 33 : else if (TailMatches("INSERT", "INTO", MatchAny))
4111 UBC 0 : COMPLETE_WITH("(", "DEFAULT VALUES", "SELECT", "TABLE", "VALUES", "OVERRIDING");
4112 EUB :
4113 : /*
4114 : * Complete INSERT INTO <table> (attribs) with "VALUES" or "SELECT" or
4115 : * "TABLE" or "OVERRIDING"
4116 : */
4117 GIC 33 : else if (TailMatches("INSERT", "INTO", MatchAny, MatchAny) &&
4118 UIC 0 : ends_with(prev_wd, ')'))
4119 0 : COMPLETE_WITH("SELECT", "TABLE", "VALUES", "OVERRIDING");
4120 :
4121 ECB : /* Complete OVERRIDING */
4122 CBC 33 : else if (TailMatches("OVERRIDING"))
4123 UBC 0 : COMPLETE_WITH("SYSTEM VALUE", "USER VALUE");
4124 :
4125 : /* Complete after OVERRIDING clause */
4126 GIC 33 : else if (TailMatches("OVERRIDING", MatchAny, "VALUE"))
4127 UIC 0 : COMPLETE_WITH("SELECT", "TABLE", "VALUES");
4128 :
4129 ECB : /* Insert an open parenthesis after "VALUES" */
4130 GBC 33 : else if (TailMatches("VALUES") && !TailMatches("DEFAULT", "VALUES"))
4131 UIC 0 : COMPLETE_WITH("(");
4132 :
4133 : /* LOCK */
4134 : /* Complete LOCK [TABLE] [ONLY] with a list of tables */
4135 CBC 33 : else if (Matches("LOCK"))
4136 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables,
4137 : "TABLE", "ONLY");
4138 GIC 33 : else if (Matches("LOCK", "TABLE"))
4139 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_tables,
4140 ECB : "ONLY");
4141 GBC 33 : else if (Matches("LOCK", "TABLE", "ONLY") || Matches("LOCK", "ONLY"))
4142 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
4143 ECB : /* For the following, handle the case of a single table only for now */
4144 EUB :
4145 ECB : /* Complete LOCK [TABLE] [ONLY] <table> with IN or NOWAIT */
4146 GBC 66 : else if (Matches("LOCK", MatchAnyExcept("TABLE|ONLY")) ||
4147 GIC 66 : Matches("LOCK", "TABLE", MatchAnyExcept("ONLY")) ||
4148 66 : Matches("LOCK", "ONLY", MatchAny) ||
4149 CBC 33 : Matches("LOCK", "TABLE", "ONLY", MatchAny))
4150 UBC 0 : COMPLETE_WITH("IN", "NOWAIT");
4151 :
4152 : /* Complete LOCK [TABLE] [ONLY] <table> IN with a lock mode */
4153 CBC 33 : else if (HeadMatches("LOCK") && TailMatches("IN"))
4154 UBC 0 : COMPLETE_WITH("ACCESS SHARE MODE",
4155 ECB : "ROW SHARE MODE", "ROW EXCLUSIVE MODE",
4156 EUB : "SHARE UPDATE EXCLUSIVE MODE", "SHARE MODE",
4157 : "SHARE ROW EXCLUSIVE MODE",
4158 : "EXCLUSIVE MODE", "ACCESS EXCLUSIVE MODE");
4159 ECB :
4160 : /*
4161 : * Complete LOCK [TABLE][ONLY] <table> IN ACCESS|ROW with rest of lock
4162 EUB : * mode
4163 : */
4164 GIC 33 : else if (HeadMatches("LOCK") && TailMatches("IN", "ACCESS|ROW"))
4165 UBC 0 : COMPLETE_WITH("EXCLUSIVE MODE", "SHARE MODE");
4166 :
4167 : /* Complete LOCK [TABLE] [ONLY] <table> IN SHARE with rest of lock mode */
4168 GIC 33 : else if (HeadMatches("LOCK") && TailMatches("IN", "SHARE"))
4169 LBC 0 : COMPLETE_WITH("MODE", "ROW EXCLUSIVE MODE",
4170 ECB : "UPDATE EXCLUSIVE MODE");
4171 :
4172 EUB : /* Complete LOCK [TABLE] [ONLY] <table> [IN lockmode MODE] with "NOWAIT" */
4173 GBC 33 : else if (HeadMatches("LOCK") && TailMatches("MODE"))
4174 UIC 0 : COMPLETE_WITH("NOWAIT");
4175 EUB :
4176 : /* MERGE --- can be inside EXPLAIN */
4177 GIC 33 : else if (TailMatches("MERGE"))
4178 UIC 0 : COMPLETE_WITH("INTO");
4179 CBC 33 : else if (TailMatches("MERGE", "INTO"))
4180 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_mergetargets);
4181 :
4182 EUB : /* Complete MERGE INTO <table> [[AS] <alias>] with USING */
4183 GBC 33 : else if (TailMatches("MERGE", "INTO", MatchAny))
4184 UIC 0 : COMPLETE_WITH("USING", "AS");
4185 GBC 66 : else if (TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny) ||
4186 GIC 33 : TailMatches("MERGE", "INTO", MatchAny, MatchAnyExcept("USING|AS")))
4187 UIC 0 : COMPLETE_WITH("USING");
4188 :
4189 ECB : /*
4190 EUB : * Complete MERGE INTO ... USING with a list of relations supporting
4191 : * SELECT
4192 : */
4193 CBC 66 : else if (TailMatches("MERGE", "INTO", MatchAny, "USING") ||
4194 GBC 66 : TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING") ||
4195 CBC 33 : TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING"))
4196 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables);
4197 ECB :
4198 EUB : /*
4199 ECB : * Complete MERGE INTO <table> [[AS] <alias>] USING <relations> [[AS]
4200 : * alias] with ON
4201 EUB : */
4202 CBC 66 : else if (TailMatches("MERGE", "INTO", MatchAny, "USING", MatchAny) ||
4203 GBC 66 : TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING", MatchAny) ||
4204 CBC 33 : TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING", MatchAny))
4205 UBC 0 : COMPLETE_WITH("AS", "ON");
4206 CBC 66 : else if (TailMatches("MERGE", "INTO", MatchAny, "USING", MatchAny, "AS", MatchAny) ||
4207 GBC 66 : TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING", MatchAny, "AS", MatchAny) ||
4208 GIC 66 : TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING", MatchAny, "AS", MatchAny) ||
4209 66 : TailMatches("MERGE", "INTO", MatchAny, "USING", MatchAny, MatchAnyExcept("ON|AS")) ||
4210 66 : TailMatches("MERGE", "INTO", MatchAny, "AS", MatchAny, "USING", MatchAny, MatchAnyExcept("ON|AS")) ||
4211 CBC 33 : TailMatches("MERGE", "INTO", MatchAny, MatchAny, "USING", MatchAny, MatchAnyExcept("ON|AS")))
4212 UBC 0 : COMPLETE_WITH("ON");
4213 :
4214 ECB : /* Complete MERGE INTO ... ON with target table attributes */
4215 GBC 33 : else if (TailMatches("INTO", MatchAny, "USING", MatchAny, "ON"))
4216 UIC 0 : COMPLETE_WITH_ATTR(prev4_wd);
4217 CBC 33 : else if (TailMatches("INTO", MatchAny, "AS", MatchAny, "USING", MatchAny, "AS", MatchAny, "ON"))
4218 UBC 0 : COMPLETE_WITH_ATTR(prev8_wd);
4219 GIC 33 : else if (TailMatches("INTO", MatchAny, MatchAny, "USING", MatchAny, MatchAny, "ON"))
4220 LBC 0 : COMPLETE_WITH_ATTR(prev6_wd);
4221 EUB :
4222 : /*
4223 : * Complete ... USING <relation> [[AS] alias] ON join condition
4224 : * (consisting of one or three words typically used) with WHEN [NOT]
4225 : * MATCHED
4226 : */
4227 CBC 66 : else if (TailMatches("USING", MatchAny, "ON", MatchAny) ||
4228 GBC 66 : TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny) ||
4229 GIC 66 : TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny) ||
4230 66 : TailMatches("USING", MatchAny, "ON", MatchAny, MatchAnyExcept("WHEN"), MatchAnyExcept("WHEN")) ||
4231 66 : TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny, MatchAnyExcept("WHEN"), MatchAnyExcept("WHEN")) ||
4232 33 : TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny, MatchAnyExcept("WHEN"), MatchAnyExcept("WHEN")))
4233 UIC 0 : COMPLETE_WITH("WHEN MATCHED", "WHEN NOT MATCHED");
4234 CBC 66 : else if (TailMatches("USING", MatchAny, "ON", MatchAny, "WHEN") ||
4235 GBC 66 : TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny, "WHEN") ||
4236 66 : TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny, "WHEN") ||
4237 GIC 66 : TailMatches("USING", MatchAny, "ON", MatchAny, MatchAny, MatchAny, "WHEN") ||
4238 66 : TailMatches("USING", MatchAny, "AS", MatchAny, "ON", MatchAny, MatchAny, MatchAny, "WHEN") ||
4239 CBC 33 : TailMatches("USING", MatchAny, MatchAny, "ON", MatchAny, MatchAny, MatchAny, "WHEN"))
4240 UBC 0 : COMPLETE_WITH("MATCHED", "NOT MATCHED");
4241 :
4242 : /* Complete ... WHEN [NOT] MATCHED with THEN/AND */
4243 CBC 66 : else if (TailMatches("WHEN", "MATCHED") ||
4244 GBC 33 : TailMatches("WHEN", "NOT", "MATCHED"))
4245 UIC 0 : COMPLETE_WITH("THEN", "AND");
4246 :
4247 ECB : /* Complete ... WHEN MATCHED THEN with UPDATE SET/DELETE/DO NOTHING */
4248 GBC 33 : else if (TailMatches("WHEN", "MATCHED", "THEN"))
4249 UIC 0 : COMPLETE_WITH("UPDATE SET", "DELETE", "DO NOTHING");
4250 :
4251 : /* Complete ... WHEN NOT MATCHED THEN with INSERT/DO NOTHING */
4252 CBC 33 : else if (TailMatches("WHEN", "NOT", "MATCHED", "THEN"))
4253 UBC 0 : COMPLETE_WITH("INSERT", "DO NOTHING");
4254 :
4255 ECB : /* NOTIFY --- can be inside EXPLAIN, RULE, etc */
4256 GBC 33 : else if (TailMatches("NOTIFY"))
4257 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_channels);
4258 ECB :
4259 EUB : /* OPTIONS */
4260 GIC 33 : else if (TailMatches("OPTIONS"))
4261 UIC 0 : COMPLETE_WITH("(");
4262 :
4263 ECB : /* OWNER TO - complete with available roles */
4264 CBC 33 : else if (TailMatches("OWNER", "TO"))
4265 UNC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
4266 : "CURRENT_ROLE",
4267 : "CURRENT_USER",
4268 : "SESSION_USER");
4269 ECB :
4270 EUB : /* ORDER BY */
4271 GIC 33 : else if (TailMatches("FROM", MatchAny, "ORDER"))
4272 UIC 0 : COMPLETE_WITH("BY");
4273 CBC 33 : else if (TailMatches("FROM", MatchAny, "ORDER", "BY"))
4274 UBC 0 : COMPLETE_WITH_ATTR(prev3_wd);
4275 :
4276 : /* PREPARE xx AS */
4277 GIC 33 : else if (Matches("PREPARE", MatchAny, "AS"))
4278 UIC 0 : COMPLETE_WITH("SELECT", "UPDATE", "INSERT INTO", "DELETE FROM");
4279 :
4280 : /*
4281 : * PREPARE TRANSACTION is missing on purpose. It's intended for transaction
4282 : * managers, not for manual use in interactive sessions.
4283 : */
4284 ECB :
4285 EUB : /* REASSIGN OWNED BY xxx TO yyy */
4286 GIC 33 : else if (Matches("REASSIGN"))
4287 UIC 0 : COMPLETE_WITH("OWNED BY");
4288 CBC 33 : else if (Matches("REASSIGN", "OWNED"))
4289 UBC 0 : COMPLETE_WITH("BY");
4290 GIC 33 : else if (Matches("REASSIGN", "OWNED", "BY"))
4291 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
4292 GIC 33 : else if (Matches("REASSIGN", "OWNED", "BY", MatchAny))
4293 LBC 0 : COMPLETE_WITH("TO");
4294 GBC 33 : else if (Matches("REASSIGN", "OWNED", "BY", MatchAny, "TO"))
4295 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
4296 :
4297 ECB : /* REFRESH MATERIALIZED VIEW */
4298 GBC 33 : else if (Matches("REFRESH"))
4299 LBC 0 : COMPLETE_WITH("MATERIALIZED VIEW");
4300 GBC 33 : else if (Matches("REFRESH", "MATERIALIZED"))
4301 UIC 0 : COMPLETE_WITH("VIEW");
4302 GIC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW"))
4303 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_matviews,
4304 EUB : "CONCURRENTLY");
4305 CBC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY"))
4306 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews);
4307 GBC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", MatchAny))
4308 UIC 0 : COMPLETE_WITH("WITH");
4309 GIC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY", MatchAny))
4310 UIC 0 : COMPLETE_WITH("WITH");
4311 GIC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", MatchAny, "WITH"))
4312 UIC 0 : COMPLETE_WITH("NO DATA", "DATA");
4313 CBC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY", MatchAny, "WITH"))
4314 LBC 0 : COMPLETE_WITH("NO DATA", "DATA");
4315 CBC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", MatchAny, "WITH", "NO"))
4316 UBC 0 : COMPLETE_WITH("DATA");
4317 GIC 33 : else if (Matches("REFRESH", "MATERIALIZED", "VIEW", "CONCURRENTLY", MatchAny, "WITH", "NO"))
4318 UIC 0 : COMPLETE_WITH("DATA");
4319 :
4320 : /* REINDEX */
4321 GIC 66 : else if (Matches("REINDEX") ||
4322 CBC 33 : Matches("REINDEX", "(*)"))
4323 LBC 0 : COMPLETE_WITH("TABLE", "INDEX", "SYSTEM", "SCHEMA", "DATABASE");
4324 CBC 66 : else if (Matches("REINDEX", "TABLE") ||
4325 GBC 33 : Matches("REINDEX", "(*)", "TABLE"))
4326 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexables,
4327 ECB : "CONCURRENTLY");
4328 CBC 66 : else if (Matches("REINDEX", "INDEX") ||
4329 33 : Matches("REINDEX", "(*)", "INDEX"))
4330 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_indexes,
4331 ECB : "CONCURRENTLY");
4332 GBC 66 : else if (Matches("REINDEX", "SCHEMA") ||
4333 GIC 33 : Matches("REINDEX", "(*)", "SCHEMA"))
4334 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas,
4335 ECB : "CONCURRENTLY");
4336 GBC 66 : else if (Matches("REINDEX", "SYSTEM|DATABASE") ||
4337 CBC 33 : Matches("REINDEX", "(*)", "SYSTEM|DATABASE"))
4338 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_databases,
4339 ECB : "CONCURRENTLY");
4340 GBC 66 : else if (Matches("REINDEX", "TABLE", "CONCURRENTLY") ||
4341 GIC 33 : Matches("REINDEX", "(*)", "TABLE", "CONCURRENTLY"))
4342 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexables);
4343 GIC 66 : else if (Matches("REINDEX", "INDEX", "CONCURRENTLY") ||
4344 33 : Matches("REINDEX", "(*)", "INDEX", "CONCURRENTLY"))
4345 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes);
4346 GIC 66 : else if (Matches("REINDEX", "SCHEMA", "CONCURRENTLY") ||
4347 CBC 33 : Matches("REINDEX", "(*)", "SCHEMA", "CONCURRENTLY"))
4348 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
4349 CBC 66 : else if (Matches("REINDEX", "SYSTEM|DATABASE", "CONCURRENTLY") ||
4350 33 : Matches("REINDEX", "(*)", "SYSTEM|DATABASE", "CONCURRENTLY"))
4351 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_databases);
4352 CBC 33 : else if (HeadMatches("REINDEX", "(*") &&
4353 UBC 0 : !HeadMatches("REINDEX", "(*)"))
4354 ECB : {
4355 : /*
4356 : * This fires if we're in an unfinished parenthesized option list.
4357 : * get_previous_words treats a completed parenthesized option list as
4358 : * one word, so the above test is correct.
4359 : */
4360 UBC 0 : if (ends_with(prev_wd, '(') || ends_with(prev_wd, ','))
4361 UIC 0 : COMPLETE_WITH("CONCURRENTLY", "TABLESPACE", "VERBOSE");
4362 0 : else if (TailMatches("TABLESPACE"))
4363 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
4364 ECB : }
4365 EUB :
4366 : /* SECURITY LABEL */
4367 GIC 33 : else if (Matches("SECURITY"))
4368 LBC 0 : COMPLETE_WITH("LABEL");
4369 GBC 33 : else if (Matches("SECURITY", "LABEL"))
4370 UIC 0 : COMPLETE_WITH("ON", "FOR");
4371 GIC 33 : else if (Matches("SECURITY", "LABEL", "FOR", MatchAny))
4372 LBC 0 : COMPLETE_WITH("ON");
4373 GBC 66 : else if (Matches("SECURITY", "LABEL", "ON") ||
4374 GIC 33 : Matches("SECURITY", "LABEL", "FOR", MatchAny, "ON"))
4375 UIC 0 : COMPLETE_WITH("TABLE", "COLUMN", "AGGREGATE", "DATABASE", "DOMAIN",
4376 ECB : "EVENT TRIGGER", "FOREIGN TABLE", "FUNCTION",
4377 EUB : "LARGE OBJECT", "MATERIALIZED VIEW", "LANGUAGE",
4378 : "PUBLICATION", "PROCEDURE", "ROLE", "ROUTINE", "SCHEMA",
4379 : "SEQUENCE", "SUBSCRIPTION", "TABLESPACE", "TYPE", "VIEW");
4380 CBC 33 : else if (Matches("SECURITY", "LABEL", "ON", MatchAny, MatchAny))
4381 UBC 0 : COMPLETE_WITH("IS");
4382 :
4383 : /* SELECT */
4384 ECB : /* naah . . . */
4385 EUB :
4386 : /* SET, RESET, SHOW */
4387 : /* Complete with a variable name */
4388 GIC 33 : else if (TailMatches("SET|RESET") && !TailMatches("UPDATE", MatchAny, "SET"))
4389 3 : COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_set_vars,
4390 : "CONSTRAINTS",
4391 ECB : "TRANSACTION",
4392 EUB : "SESSION",
4393 ECB : "ROLE",
4394 EUB : "TABLESPACE",
4395 : "ALL");
4396 GIC 30 : else if (Matches("SHOW"))
4397 LBC 0 : COMPLETE_WITH_QUERY_VERBATIM_PLUS(Query_for_list_of_show_vars,
4398 EUB : "SESSION AUTHORIZATION",
4399 : "ALL");
4400 GIC 30 : else if (Matches("SHOW", "SESSION"))
4401 UIC 0 : COMPLETE_WITH("AUTHORIZATION");
4402 : /* Complete "SET TRANSACTION" */
4403 GIC 30 : else if (Matches("SET", "TRANSACTION"))
4404 UIC 0 : COMPLETE_WITH("SNAPSHOT", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE");
4405 GIC 60 : else if (Matches("BEGIN|START", "TRANSACTION") ||
4406 CBC 60 : Matches("BEGIN", "WORK") ||
4407 GBC 60 : Matches("BEGIN") ||
4408 CBC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION"))
4409 UBC 0 : COMPLETE_WITH("ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE");
4410 CBC 60 : else if (Matches("SET|BEGIN|START", "TRANSACTION|WORK", "NOT") ||
4411 GBC 60 : Matches("BEGIN", "NOT") ||
4412 CBC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "NOT"))
4413 UBC 0 : COMPLETE_WITH("DEFERRABLE");
4414 CBC 60 : else if (Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION") ||
4415 GBC 60 : Matches("BEGIN", "ISOLATION") ||
4416 GIC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION"))
4417 UIC 0 : COMPLETE_WITH("LEVEL");
4418 CBC 60 : else if (Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION", "LEVEL") ||
4419 GBC 60 : Matches("BEGIN", "ISOLATION", "LEVEL") ||
4420 CBC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION", "LEVEL"))
4421 UBC 0 : COMPLETE_WITH("READ", "REPEATABLE READ", "SERIALIZABLE");
4422 CBC 60 : else if (Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION", "LEVEL", "READ") ||
4423 GBC 60 : Matches("BEGIN", "ISOLATION", "LEVEL", "READ") ||
4424 GIC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION", "LEVEL", "READ"))
4425 LBC 0 : COMPLETE_WITH("UNCOMMITTED", "COMMITTED");
4426 GBC 60 : else if (Matches("SET|BEGIN|START", "TRANSACTION|WORK", "ISOLATION", "LEVEL", "REPEATABLE") ||
4427 CBC 60 : Matches("BEGIN", "ISOLATION", "LEVEL", "REPEATABLE") ||
4428 GBC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "ISOLATION", "LEVEL", "REPEATABLE"))
4429 LBC 0 : COMPLETE_WITH("READ");
4430 GBC 60 : else if (Matches("SET|BEGIN|START", "TRANSACTION|WORK", "READ") ||
4431 CBC 60 : Matches("BEGIN", "READ") ||
4432 GBC 30 : Matches("SET", "SESSION", "CHARACTERISTICS", "AS", "TRANSACTION", "READ"))
4433 LBC 0 : COMPLETE_WITH("ONLY", "WRITE");
4434 EUB : /* SET CONSTRAINTS */
4435 CBC 30 : else if (Matches("SET", "CONSTRAINTS"))
4436 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_constraints_with_schema,
4437 ECB : "ALL");
4438 EUB : /* Complete SET CONSTRAINTS <foo> with DEFERRED|IMMEDIATE */
4439 GIC 30 : else if (Matches("SET", "CONSTRAINTS", MatchAny))
4440 UIC 0 : COMPLETE_WITH("DEFERRED", "IMMEDIATE");
4441 ECB : /* Complete SET ROLE */
4442 CBC 30 : else if (Matches("SET", "ROLE"))
4443 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
4444 ECB : /* Complete SET SESSION with AUTHORIZATION or CHARACTERISTICS... */
4445 CBC 30 : else if (Matches("SET", "SESSION"))
4446 UBC 0 : COMPLETE_WITH("AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION");
4447 : /* Complete SET SESSION AUTHORIZATION with username */
4448 CBC 30 : else if (Matches("SET", "SESSION", "AUTHORIZATION"))
4449 LBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
4450 EUB : "DEFAULT");
4451 : /* Complete RESET SESSION with AUTHORIZATION */
4452 CBC 30 : else if (Matches("RESET", "SESSION"))
4453 LBC 0 : COMPLETE_WITH("AUTHORIZATION");
4454 EUB : /* Complete SET <var> with "TO" */
4455 GIC 30 : else if (Matches("SET", MatchAny))
4456 CBC 2 : COMPLETE_WITH("TO");
4457 ECB :
4458 EUB : /*
4459 : * Complete ALTER DATABASE|FUNCTION|PROCEDURE|ROLE|ROUTINE|USER ... SET
4460 ECB : * <name>
4461 : */
4462 GBC 28 : else if (HeadMatches("ALTER", "DATABASE|FUNCTION|PROCEDURE|ROLE|ROUTINE|USER") &&
4463 LBC 0 : TailMatches("SET", MatchAny) &&
4464 0 : !TailMatches("SCHEMA"))
4465 UBC 0 : COMPLETE_WITH("FROM CURRENT", "TO");
4466 ECB :
4467 : /*
4468 EUB : * Suggest possible variable values in SET variable TO|=, along with the
4469 ECB : * preceding ALTER syntaxes.
4470 : */
4471 GBC 28 : else if (TailMatches("SET", MatchAny, "TO|=") &&
4472 CBC 4 : !TailMatches("UPDATE", MatchAny, "SET", MatchAny, "TO|="))
4473 EUB : {
4474 : /* special cased code for individual GUCs */
4475 GIC 4 : if (TailMatches("DateStyle", "TO|="))
4476 UIC 0 : COMPLETE_WITH("ISO", "SQL", "Postgres", "German",
4477 : "YMD", "DMY", "MDY",
4478 : "US", "European", "NonEuropean",
4479 : "DEFAULT");
4480 GBC 4 : else if (TailMatches("search_path", "TO|="))
4481 EUB : {
4482 : /* Here, we want to allow pg_catalog, so use narrower exclusion */
4483 UBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_schemas
4484 : " AND nspname NOT LIKE E'pg\\\\_toast%%'"
4485 : " AND nspname NOT LIKE E'pg\\\\_temp%%'",
4486 : "DEFAULT");
4487 ECB : }
4488 GBC 4 : else if (TailMatches("TimeZone", "TO|="))
4489 CBC 2 : COMPLETE_WITH_TIMEZONE_NAME();
4490 EUB : else
4491 ECB : {
4492 EUB : /* generic, type based, GUC support */
4493 CBC 2 : char *guctype = get_guctype(prev2_wd);
4494 ECB :
4495 EUB : /*
4496 : * Note: if we don't recognize the GUC name, it's important to not
4497 : * offer any completions, as most likely we've misinterpreted the
4498 : * context and this isn't a GUC-setting command at all.
4499 : */
4500 CBC 2 : if (guctype)
4501 EUB : {
4502 GIC 2 : if (strcmp(guctype, "enum") == 0)
4503 : {
4504 2 : set_completion_reference_verbatim(prev2_wd);
4505 2 : COMPLETE_WITH_QUERY_PLUS(Query_for_values_of_enum_GUC,
4506 : "DEFAULT");
4507 : }
4508 LBC 0 : else if (strcmp(guctype, "bool") == 0)
4509 0 : COMPLETE_WITH("on", "off", "true", "false", "yes", "no",
4510 : "1", "0", "DEFAULT");
4511 : else
4512 UIC 0 : COMPLETE_WITH("DEFAULT");
4513 :
4514 GIC 2 : free(guctype);
4515 : }
4516 ECB : }
4517 EUB : }
4518 : /* Complete ALTER DATABASE|ROLE|USER ... SET ... TO ... USER SET */
4519 GNC 24 : else if (HeadMatches("ALTER", "DATABASE|ROLE|USER") &&
4520 UNC 0 : TailMatches("SET", MatchAny, "TO|=", MatchAny))
4521 0 : COMPLETE_WITH("USER SET");
4522 :
4523 : /* START TRANSACTION */
4524 CBC 24 : else if (Matches("START"))
4525 UBC 0 : COMPLETE_WITH("TRANSACTION");
4526 :
4527 ECB : /* TABLE, but not TABLE embedded in other commands */
4528 GBC 24 : else if (Matches("TABLE"))
4529 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables);
4530 ECB :
4531 : /* TABLESAMPLE */
4532 CBC 24 : else if (TailMatches("TABLESAMPLE"))
4533 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_tablesample_methods);
4534 CBC 24 : else if (TailMatches("TABLESAMPLE", MatchAny))
4535 LBC 0 : COMPLETE_WITH("(");
4536 ECB :
4537 EUB : /* TRUNCATE */
4538 CBC 24 : else if (Matches("TRUNCATE"))
4539 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_truncatables,
4540 ECB : "TABLE", "ONLY");
4541 GBC 24 : else if (Matches("TRUNCATE", "TABLE"))
4542 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_truncatables,
4543 ECB : "ONLY");
4544 CBC 24 : else if (HeadMatches("TRUNCATE") && TailMatches("ONLY"))
4545 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_truncatables);
4546 CBC 48 : else if (Matches("TRUNCATE", MatchAny) ||
4547 48 : Matches("TRUNCATE", "TABLE|ONLY", MatchAny) ||
4548 24 : Matches("TRUNCATE", "TABLE", "ONLY", MatchAny))
4549 UBC 0 : COMPLETE_WITH("RESTART IDENTITY", "CONTINUE IDENTITY", "CASCADE", "RESTRICT");
4550 CBC 24 : else if (HeadMatches("TRUNCATE") && TailMatches("IDENTITY"))
4551 LBC 0 : COMPLETE_WITH("CASCADE", "RESTRICT");
4552 ECB :
4553 EUB : /* UNLISTEN */
4554 CBC 24 : else if (Matches("UNLISTEN"))
4555 LBC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_channels, "*");
4556 ECB :
4557 EUB : /* UPDATE --- can be inside EXPLAIN, RULE, etc */
4558 : /* If prev. word is UPDATE suggest a list of tables */
4559 CBC 24 : else if (TailMatches("UPDATE"))
4560 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_updatables);
4561 : /* Complete UPDATE <table> with "SET" */
4562 GIC 24 : else if (TailMatches("UPDATE", MatchAny))
4563 LBC 0 : COMPLETE_WITH("SET");
4564 EUB : /* Complete UPDATE <table> SET with list of attributes */
4565 GIC 24 : else if (TailMatches("UPDATE", MatchAny, "SET"))
4566 LBC 0 : COMPLETE_WITH_ATTR(prev2_wd);
4567 EUB : /* UPDATE <table> SET <attr> = */
4568 GIC 24 : else if (TailMatches("UPDATE", MatchAny, "SET", MatchAnyExcept("*=")))
4569 LBC 0 : COMPLETE_WITH("=");
4570 EUB :
4571 : /* USER MAPPING */
4572 CBC 24 : else if (Matches("ALTER|CREATE|DROP", "USER", "MAPPING"))
4573 UBC 0 : COMPLETE_WITH("FOR");
4574 GIC 24 : else if (Matches("CREATE", "USER", "MAPPING", "FOR"))
4575 UIC 0 : COMPLETE_WITH_QUERY_PLUS(Query_for_list_of_roles,
4576 ECB : "CURRENT_ROLE",
4577 EUB : "CURRENT_USER",
4578 : "PUBLIC",
4579 ECB : "USER");
4580 CBC 24 : else if (Matches("ALTER|DROP", "USER", "MAPPING", "FOR"))
4581 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings);
4582 GIC 24 : else if (Matches("CREATE|ALTER|DROP", "USER", "MAPPING", "FOR", MatchAny))
4583 UIC 0 : COMPLETE_WITH("SERVER");
4584 GIC 24 : else if (Matches("CREATE|ALTER", "USER", "MAPPING", "FOR", MatchAny, "SERVER", MatchAny))
4585 UIC 0 : COMPLETE_WITH("OPTIONS");
4586 ECB :
4587 EUB : /*
4588 : * VACUUM [ ( option [, ...] ) ] [ table_and_columns [, ...] ]
4589 : * VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ ANALYZE ] [ table_and_columns [, ...] ]
4590 : */
4591 GIC 24 : else if (Matches("VACUUM"))
4592 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables,
4593 : "FULL",
4594 : "FREEZE",
4595 ECB : "ANALYZE",
4596 : "VERBOSE");
4597 GIC 24 : else if (Matches("VACUUM", "FULL"))
4598 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables,
4599 ECB : "FREEZE",
4600 EUB : "ANALYZE",
4601 : "VERBOSE");
4602 GIC 48 : else if (Matches("VACUUM", "FREEZE") ||
4603 24 : Matches("VACUUM", "FULL", "FREEZE"))
4604 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables,
4605 : "VERBOSE",
4606 : "ANALYZE");
4607 GBC 48 : else if (Matches("VACUUM", "VERBOSE") ||
4608 GIC 48 : Matches("VACUUM", "FULL|FREEZE", "VERBOSE") ||
4609 24 : Matches("VACUUM", "FULL", "FREEZE", "VERBOSE"))
4610 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY_PLUS(Query_for_list_of_vacuumables,
4611 : "ANALYZE");
4612 CBC 24 : else if (HeadMatches("VACUUM", "(*") &&
4613 LBC 0 : !HeadMatches("VACUUM", "(*)"))
4614 : {
4615 : /*
4616 : * This fires if we're in an unfinished parenthesized option list.
4617 ECB : * get_previous_words treats a completed parenthesized option list as
4618 : * one word, so the above test is correct.
4619 : */
4620 UIC 0 : if (ends_with(prev_wd, '(') || ends_with(prev_wd, ','))
4621 0 : COMPLETE_WITH("FULL", "FREEZE", "ANALYZE", "VERBOSE",
4622 : "DISABLE_PAGE_SKIPPING", "SKIP_LOCKED",
4623 : "INDEX_CLEANUP", "PROCESS_MAIN", "PROCESS_TOAST",
4624 : "TRUNCATE", "PARALLEL", "SKIP_DATABASE_STATS",
4625 : "ONLY_DATABASE_STATS", "BUFFER_USAGE_LIMIT");
4626 UNC 0 : else if (TailMatches("FULL|FREEZE|ANALYZE|VERBOSE|DISABLE_PAGE_SKIPPING|SKIP_LOCKED|PROCESS_MAIN|PROCESS_TOAST|TRUNCATE|SKIP_DATABASE_STATS|ONLY_DATABASE_STATS"))
4627 LBC 0 : COMPLETE_WITH("ON", "OFF");
4628 UIC 0 : else if (TailMatches("INDEX_CLEANUP"))
4629 LBC 0 : COMPLETE_WITH("AUTO", "ON", "OFF");
4630 ECB : }
4631 GIC 24 : else if (HeadMatches("VACUUM") && TailMatches("("))
4632 : /* "VACUUM (" should be caught above, so assume we want columns */
4633 UBC 0 : COMPLETE_WITH_ATTR(prev2_wd);
4634 GBC 24 : else if (HeadMatches("VACUUM"))
4635 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_vacuumables);
4636 :
4637 EUB : /* WITH [RECURSIVE] */
4638 :
4639 ECB : /*
4640 : * Only match when WITH is the first word, as WITH may appear in many
4641 : * other contexts.
4642 : */
4643 GIC 24 : else if (Matches("WITH"))
4644 LBC 0 : COMPLETE_WITH("RECURSIVE");
4645 EUB :
4646 : /* WHERE */
4647 : /* Simple case of the word before the where being the table name */
4648 GIC 24 : else if (TailMatches(MatchAny, "WHERE"))
4649 LBC 0 : COMPLETE_WITH_ATTR(prev2_wd);
4650 EUB :
4651 : /* ... FROM ... */
4652 : /* TODO: also include SRF ? */
4653 CBC 24 : else if (TailMatches("FROM") && !Matches("COPY|\\copy", MatchAny, "FROM"))
4654 GBC 14 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables);
4655 :
4656 : /* ... JOIN ... */
4657 CBC 10 : else if (TailMatches("JOIN"))
4658 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_selectables);
4659 ECB :
4660 EUB : /* Backslash commands */
4661 : /* TODO: \dc \dd \dl */
4662 GIC 10 : else if (TailMatchesCS("\\?"))
4663 LBC 0 : COMPLETE_WITH_CS("commands", "options", "variables");
4664 GBC 10 : else if (TailMatchesCS("\\connect|\\c"))
4665 : {
4666 LBC 0 : if (!recognized_connection_string(text))
4667 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_databases);
4668 : }
4669 CBC 10 : else if (TailMatchesCS("\\connect|\\c", MatchAny))
4670 EUB : {
4671 LBC 0 : if (!recognized_connection_string(prev_wd))
4672 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
4673 ECB : }
4674 GBC 10 : else if (TailMatchesCS("\\da*"))
4675 LBC 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_aggregates);
4676 GBC 20 : else if (TailMatchesCS("\\dAc*", MatchAny) ||
4677 GIC 10 : TailMatchesCS("\\dAf*", MatchAny))
4678 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
4679 CBC 20 : else if (TailMatchesCS("\\dAo*", MatchAny) ||
4680 GBC 10 : TailMatchesCS("\\dAp*", MatchAny))
4681 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_operator_families);
4682 GIC 10 : else if (TailMatchesCS("\\dA*"))
4683 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_access_methods);
4684 CBC 10 : else if (TailMatchesCS("\\db*"))
4685 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
4686 GIC 10 : else if (TailMatchesCS("\\dconfig*"))
4687 LBC 0 : COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_show_vars);
4688 GBC 10 : else if (TailMatchesCS("\\dD*"))
4689 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains);
4690 CBC 10 : else if (TailMatchesCS("\\des*"))
4691 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_servers);
4692 GIC 10 : else if (TailMatchesCS("\\deu*"))
4693 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings);
4694 GBC 10 : else if (TailMatchesCS("\\dew*"))
4695 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_fdws);
4696 GIC 10 : else if (TailMatchesCS("\\df*"))
4697 LBC 0 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_functions);
4698 GBC 10 : else if (HeadMatchesCS("\\df*"))
4699 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
4700 EUB :
4701 GIC 10 : else if (TailMatchesCS("\\dFd*"))
4702 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_dictionaries);
4703 GIC 10 : else if (TailMatchesCS("\\dFp*"))
4704 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_parsers);
4705 CBC 10 : else if (TailMatchesCS("\\dFt*"))
4706 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_templates);
4707 ECB : /* must be at end of \dF alternatives: */
4708 GBC 10 : else if (TailMatchesCS("\\dF*"))
4709 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_ts_configurations);
4710 EUB :
4711 GIC 10 : else if (TailMatchesCS("\\di*"))
4712 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes);
4713 GIC 10 : else if (TailMatchesCS("\\dL*"))
4714 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_languages);
4715 GIC 10 : else if (TailMatchesCS("\\dn*"))
4716 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_schemas);
4717 EUB : /* no support for completing operators, but we can complete types: */
4718 GIC 10 : else if (HeadMatchesCS("\\do*", MatchAny))
4719 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
4720 GIC 10 : else if (TailMatchesCS("\\dp") || TailMatchesCS("\\z"))
4721 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_grantables);
4722 CBC 10 : else if (TailMatchesCS("\\dPi*"))
4723 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_indexes);
4724 GIC 10 : else if (TailMatchesCS("\\dPt*"))
4725 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables);
4726 GIC 10 : else if (TailMatchesCS("\\dP*"))
4727 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_relations);
4728 GNC 10 : else if (TailMatchesCS("\\dRp*"))
4729 UNC 0 : COMPLETE_WITH_VERSIONED_QUERY(Query_for_list_of_publications);
4730 GNC 10 : else if (TailMatchesCS("\\dRs*"))
4731 UNC 0 : COMPLETE_WITH_VERSIONED_QUERY(Query_for_list_of_subscriptions);
4732 CBC 10 : else if (TailMatchesCS("\\ds*"))
4733 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_sequences);
4734 GIC 10 : else if (TailMatchesCS("\\dt*"))
4735 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables);
4736 CBC 10 : else if (TailMatchesCS("\\dT*"))
4737 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_datatypes);
4738 CBC 10 : else if (TailMatchesCS("\\du*") || TailMatchesCS("\\dg*"))
4739 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
4740 GIC 10 : else if (TailMatchesCS("\\dv*"))
4741 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views);
4742 GBC 10 : else if (TailMatchesCS("\\dx*"))
4743 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_extensions);
4744 GIC 10 : else if (TailMatchesCS("\\dX*"))
4745 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_statistics);
4746 GIC 10 : else if (TailMatchesCS("\\dm*"))
4747 UIC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_matviews);
4748 GIC 10 : else if (TailMatchesCS("\\dE*"))
4749 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_foreign_tables);
4750 GBC 10 : else if (TailMatchesCS("\\dy*"))
4751 UIC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_event_triggers);
4752 :
4753 : /* must be at end of \d alternatives: */
4754 GIC 10 : else if (TailMatchesCS("\\d*"))
4755 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_relations);
4756 EUB :
4757 GBC 10 : else if (TailMatchesCS("\\ef"))
4758 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines);
4759 GIC 10 : else if (TailMatchesCS("\\ev"))
4760 LBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views);
4761 :
4762 GBC 10 : else if (TailMatchesCS("\\encoding"))
4763 LBC 0 : COMPLETE_WITH_QUERY_VERBATIM(Query_for_list_of_encodings);
4764 GBC 10 : else if (TailMatchesCS("\\h|\\help"))
4765 UIC 0 : COMPLETE_WITH_LIST(sql_commands);
4766 GIC 10 : else if (TailMatchesCS("\\h|\\help", MatchAny))
4767 : {
4768 UIC 0 : if (TailMatches("DROP"))
4769 0 : matches = rl_completion_matches(text, drop_command_generator);
4770 0 : else if (TailMatches("ALTER"))
4771 0 : matches = rl_completion_matches(text, alter_command_generator);
4772 ECB :
4773 EUB : /*
4774 : * CREATE is recognized by tail match elsewhere, so doesn't need to be
4775 : * repeated here
4776 : */
4777 ECB : }
4778 GBC 10 : else if (TailMatchesCS("\\h|\\help", MatchAny, MatchAny))
4779 : {
4780 UIC 0 : if (TailMatches("CREATE|DROP", "ACCESS"))
4781 0 : COMPLETE_WITH("METHOD");
4782 LBC 0 : else if (TailMatches("ALTER", "DEFAULT"))
4783 0 : COMPLETE_WITH("PRIVILEGES");
4784 UIC 0 : else if (TailMatches("CREATE|ALTER|DROP", "EVENT"))
4785 0 : COMPLETE_WITH("TRIGGER");
4786 LBC 0 : else if (TailMatches("CREATE|ALTER|DROP", "FOREIGN"))
4787 UBC 0 : COMPLETE_WITH("DATA WRAPPER", "TABLE");
4788 UIC 0 : else if (TailMatches("ALTER", "LARGE"))
4789 0 : COMPLETE_WITH("OBJECT");
4790 0 : else if (TailMatches("CREATE|ALTER|DROP", "MATERIALIZED"))
4791 LBC 0 : COMPLETE_WITH("VIEW");
4792 UBC 0 : else if (TailMatches("CREATE|ALTER|DROP", "TEXT"))
4793 LBC 0 : COMPLETE_WITH("SEARCH");
4794 UIC 0 : else if (TailMatches("CREATE|ALTER|DROP", "USER"))
4795 UBC 0 : COMPLETE_WITH("MAPPING FOR");
4796 EUB : }
4797 GIC 10 : else if (TailMatchesCS("\\h|\\help", MatchAny, MatchAny, MatchAny))
4798 ECB : {
4799 UIC 0 : if (TailMatches("CREATE|ALTER|DROP", "FOREIGN", "DATA"))
4800 UBC 0 : COMPLETE_WITH("WRAPPER");
4801 0 : else if (TailMatches("CREATE|ALTER|DROP", "TEXT", "SEARCH"))
4802 UIC 0 : COMPLETE_WITH("CONFIGURATION", "DICTIONARY", "PARSER", "TEMPLATE");
4803 LBC 0 : else if (TailMatches("CREATE|ALTER|DROP", "USER", "MAPPING"))
4804 UBC 0 : COMPLETE_WITH("FOR");
4805 ECB : }
4806 CBC 10 : else if (TailMatchesCS("\\l*") && !TailMatchesCS("\\lo*"))
4807 UBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_databases);
4808 CBC 10 : else if (TailMatchesCS("\\password"))
4809 LBC 0 : COMPLETE_WITH_QUERY(Query_for_list_of_roles);
4810 GBC 10 : else if (TailMatchesCS("\\pset"))
4811 LBC 0 : COMPLETE_WITH_CS("border", "columns", "csv_fieldsep", "expanded",
4812 EUB : "fieldsep", "fieldsep_zero", "footer", "format",
4813 ECB : "linestyle", "null", "numericlocale",
4814 EUB : "pager", "pager_min_lines",
4815 ECB : "recordsep", "recordsep_zero",
4816 EUB : "tableattr", "title", "tuples_only",
4817 ECB : "unicode_border_linestyle",
4818 EUB : "unicode_column_linestyle",
4819 : "unicode_header_linestyle",
4820 : "xheader_width");
4821 GBC 10 : else if (TailMatchesCS("\\pset", MatchAny))
4822 ECB : {
4823 UBC 0 : if (TailMatchesCS("format"))
4824 LBC 0 : COMPLETE_WITH_CS("aligned", "asciidoc", "csv", "html", "latex",
4825 EUB : "latex-longtable", "troff-ms", "unaligned",
4826 ECB : "wrapped");
4827 UNC 0 : else if (TailMatchesCS("xheader_width"))
4828 0 : COMPLETE_WITH_CS("full", "column", "page");
4829 UBC 0 : else if (TailMatchesCS("linestyle"))
4830 LBC 0 : COMPLETE_WITH_CS("ascii", "old-ascii", "unicode");
4831 UBC 0 : else if (TailMatchesCS("pager"))
4832 UIC 0 : COMPLETE_WITH_CS("on", "off", "always");
4833 LBC 0 : else if (TailMatchesCS("unicode_border_linestyle|"
4834 EUB : "unicode_column_linestyle|"
4835 ECB : "unicode_header_linestyle"))
4836 UBC 0 : COMPLETE_WITH_CS("single", "double");
4837 ECB : }
4838 GBC 10 : else if (TailMatchesCS("\\unset"))
4839 UIC 0 : matches = complete_from_variables(text, "", "", true);
4840 CBC 10 : else if (TailMatchesCS("\\set"))
4841 GBC 1 : matches = complete_from_variables(text, "", "", false);
4842 GIC 9 : else if (TailMatchesCS("\\set", MatchAny))
4843 ECB : {
4844 GBC 1 : if (TailMatchesCS("AUTOCOMMIT|ON_ERROR_STOP|QUIET|SHOW_ALL_RESULTS|"
4845 ECB : "SINGLELINE|SINGLESTEP"))
4846 UBC 0 : COMPLETE_WITH_CS("on", "off");
4847 CBC 1 : else if (TailMatchesCS("COMP_KEYWORD_CASE"))
4848 UBC 0 : COMPLETE_WITH_CS("lower", "upper",
4849 : "preserve-lower", "preserve-upper");
4850 CBC 1 : else if (TailMatchesCS("ECHO"))
4851 UBC 0 : COMPLETE_WITH_CS("errors", "queries", "all", "none");
4852 CBC 1 : else if (TailMatchesCS("ECHO_HIDDEN"))
4853 UBC 0 : COMPLETE_WITH_CS("noexec", "off", "on");
4854 CBC 1 : else if (TailMatchesCS("HISTCONTROL"))
4855 UBC 0 : COMPLETE_WITH_CS("ignorespace", "ignoredups",
4856 ECB : "ignoreboth", "none");
4857 GBC 1 : else if (TailMatchesCS("ON_ERROR_ROLLBACK"))
4858 LBC 0 : COMPLETE_WITH_CS("on", "off", "interactive");
4859 GBC 1 : else if (TailMatchesCS("SHOW_CONTEXT"))
4860 LBC 0 : COMPLETE_WITH_CS("never", "errors", "always");
4861 GBC 1 : else if (TailMatchesCS("VERBOSITY"))
4862 CBC 1 : COMPLETE_WITH_CS("default", "verbose", "terse", "sqlstate");
4863 EUB : }
4864 CBC 8 : else if (TailMatchesCS("\\sf*"))
4865 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_routines);
4866 CBC 8 : else if (TailMatchesCS("\\sv*"))
4867 UBC 0 : COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_views);
4868 CBC 8 : else if (TailMatchesCS("\\cd|\\e|\\edit|\\g|\\gx|\\i|\\include|"
4869 EUB : "\\ir|\\include_relative|\\o|\\out|"
4870 ECB : "\\s|\\w|\\write|\\lo_import"))
4871 EUB : {
4872 CBC 2 : completion_charp = "\\";
4873 GBC 2 : completion_force_quote = false;
4874 CBC 2 : matches = rl_completion_matches(text, complete_from_files);
4875 EUB : }
4876 ECB :
4877 EUB : /*
4878 ECB : * Finally, we look through the list of "things", such as TABLE, INDEX and
4879 EUB : * check if that was the previous word. If so, execute the query to get a
4880 ECB : * list of them.
4881 EUB : */
4882 ECB : else
4883 EUB : {
4884 : const pgsql_thing_t *wac;
4885 :
4886 CBC 248 : for (wac = words_after_create; wac->name != NULL; wac++)
4887 EUB : {
4888 GIC 246 : if (pg_strcasecmp(prev_wd, wac->name) == 0)
4889 ECB : {
4890 GBC 4 : if (wac->query)
4891 LBC 0 : COMPLETE_WITH_QUERY_LIST(wac->query,
4892 EUB : wac->keywords);
4893 GIC 4 : else if (wac->vquery)
4894 CBC 1 : COMPLETE_WITH_VERSIONED_QUERY_LIST(wac->vquery,
4895 EUB : wac->keywords);
4896 CBC 3 : else if (wac->squery)
4897 GBC 3 : COMPLETE_WITH_VERSIONED_SCHEMA_QUERY_LIST(wac->squery,
4898 ECB : wac->keywords);
4899 GIC 4 : break;
4900 EUB : }
4901 : }
4902 : }
4903 :
4904 : /*
4905 : * If we still don't have anything to match we have to fabricate some sort
4906 : * of default list. If we were to just return NULL, readline automatically
4907 : * attempts filename completion, and that's usually no good.
4908 : */
4909 GIC 66 : if (matches == NULL)
4910 ECB : {
4911 GIC 2 : COMPLETE_WITH_CONST(true, "");
4912 EUB : /* Also, prevent Readline from appending stuff to the non-match */
4913 GBC 2 : rl_completion_append_character = '\0';
4914 EUB : #ifdef HAVE_RL_COMPLETION_SUPPRESS_QUOTE
4915 GBC 2 : rl_completion_suppress_quote = 1;
4916 EUB : #endif
4917 : }
4918 :
4919 : /* free storage */
4920 GBC 66 : free(previous_words);
4921 66 : free(words_buffer);
4922 66 : free(text_copy);
4923 GNC 66 : free(completion_ref_object);
4924 GBC 66 : completion_ref_object = NULL;
4925 GNC 66 : free(completion_ref_schema);
4926 GIC 66 : completion_ref_schema = NULL;
4927 ECB :
4928 : /* Return our Grand List O' Matches */
4929 GBC 66 : return matches;
4930 EUB : }
4931 :
4932 :
4933 : /*
4934 : * GENERATOR FUNCTIONS
4935 : *
4936 ECB : * These functions do all the actual work of completing the input. They get
4937 EUB : * passed the text so far and the count how many times they have been called
4938 ECB : * so far with the same text.
4939 EUB : * If you read the above carefully, you'll see that these don't get called
4940 ECB : * directly but through the readline interface.
4941 EUB : * The return value is expected to be the full completion of the text, going
4942 : * through a list each time, or NULL if there are no more matches. The string
4943 : * will be free()'d by readline, so you must run it through strdup() or
4944 : * something of that sort.
4945 : */
4946 :
4947 : /*
4948 : * Common routine for create_command_generator and drop_command_generator.
4949 : * Entries that have 'excluded' flags are not returned.
4950 : */
4951 ECB : static char *
4952 GIC 4 : create_or_drop_command_generator(const char *text, int state, bits32 excluded)
4953 EUB : {
4954 : static int list_index,
4955 : string_length;
4956 : const char *name;
4957 :
4958 : /* If this is the first time for this completion, init some values */
4959 GBC 4 : if (state == 0)
4960 EUB : {
4961 GBC 2 : list_index = 0;
4962 2 : string_length = strlen(text);
4963 EUB : }
4964 :
4965 : /* find something that matches */
4966 GBC 102 : while ((name = words_after_create[list_index++].name))
4967 : {
4968 CBC 100 : if ((pg_strncasecmp(name, text, string_length) == 0) &&
4969 GBC 2 : !(words_after_create[list_index - 1].flags & excluded))
4970 CBC 2 : return pg_strdup_keyword_case(name, text);
4971 ECB : }
4972 : /* if nothing matches, return NULL */
4973 GIC 2 : return NULL;
4974 ECB : }
4975 :
4976 EUB : /*
4977 ECB : * This one gives you one from a list of things you can put after CREATE
4978 EUB : * as defined above.
4979 : */
4980 ECB : static char *
4981 GBC 2 : create_command_generator(const char *text, int state)
4982 ECB : {
4983 GBC 2 : return create_or_drop_command_generator(text, state, THING_NO_CREATE);
4984 ECB : }
4985 EUB :
4986 : /*
4987 ECB : * This function gives you a list of things you can put after a DROP command.
4988 EUB : */
4989 ECB : static char *
4990 GBC 2 : drop_command_generator(const char *text, int state)
4991 ECB : {
4992 CBC 2 : return create_or_drop_command_generator(text, state, THING_NO_DROP);
4993 : }
4994 ECB :
4995 EUB : /*
4996 ECB : * This function gives you a list of things you can put after an ALTER command.
4997 EUB : */
4998 ECB : static char *
4999 UIC 0 : alter_command_generator(const char *text, int state)
5000 : {
5001 0 : return create_or_drop_command_generator(text, state, THING_NO_ALTER);
5002 ECB : }
5003 :
5004 : /*
5005 : * These functions generate lists using server queries.
5006 : * They are all wrappers for _complete_from_query.
5007 : */
5008 :
5009 : static char *
5010 GIC 185 : complete_from_query(const char *text, int state)
5011 : {
5012 : /* query is assumed to work for any server version */
5013 185 : return _complete_from_query(completion_charp, NULL, completion_charpp,
5014 : completion_verbatim, text, state);
5015 : }
5016 ECB :
5017 : static char *
5018 CBC 2 : complete_from_versioned_query(const char *text, int state)
5019 : {
5020 2 : const VersionedQuery *vquery = completion_vquery;
5021 EUB :
5022 : /* Find appropriate array element */
5023 CBC 2 : while (pset.sversion < vquery->min_server_version)
5024 LBC 0 : vquery++;
5025 : /* Fail completion if server is too old */
5026 CBC 2 : if (vquery->query == NULL)
5027 LBC 0 : return NULL;
5028 :
5029 CBC 2 : return _complete_from_query(vquery->query, NULL, completion_charpp,
5030 : completion_verbatim, text, state);
5031 : }
5032 :
5033 : static char *
5034 GIC 86 : complete_from_schema_query(const char *text, int state)
5035 : {
5036 : /* query is assumed to work for any server version */
5037 86 : return _complete_from_query(NULL, completion_squery, completion_charpp,
5038 : completion_verbatim, text, state);
5039 ECB : }
5040 :
5041 : static char *
5042 GIC 8 : complete_from_versioned_schema_query(const char *text, int state)
5043 ECB : {
5044 GIC 8 : const SchemaQuery *squery = completion_squery;
5045 ECB :
5046 : /* Find appropriate array element */
5047 GIC 8 : while (pset.sversion < squery->min_server_version)
5048 UIC 0 : squery++;
5049 : /* Fail completion if server is too old */
5050 CBC 8 : if (squery->catname == NULL)
5051 LBC 0 : return NULL;
5052 ECB :
5053 CBC 8 : return _complete_from_query(NULL, squery, completion_charpp,
5054 ECB : completion_verbatim, text, state);
5055 : }
5056 :
5057 :
5058 : /*
5059 : * This creates a list of matching things, according to a query described by
5060 : * the initial arguments. The caller has already done any work needed to
5061 : * select the appropriate query for the server's version.
5062 : *
5063 : * The query can be one of two kinds:
5064 : *
5065 : * 1. A simple query, which must contain a restriction clause of the form
5066 : * output LIKE '%s'
5067 : * where "output" is the same string that the query returns. The %s
5068 : * will be replaced by a LIKE pattern to match the already-typed text.
5069 : * There can be a second '%s', which will be replaced by a suitably-escaped
5070 : * version of the string provided in completion_ref_object. If there is a
5071 : * third '%s', it will be replaced by a suitably-escaped version of the string
5072 : * provided in completion_ref_schema. Those strings should be set up
5073 : * by calling set_completion_reference or set_completion_reference_verbatim.
5074 : * Simple queries should return a single column of matches. If "verbatim"
5075 : * is true, the matches are returned as-is; otherwise, they are taken to
5076 : * be SQL identifiers and quoted if necessary.
5077 : *
5078 : * 2. A schema query used for completion of both schema and relation names.
5079 : * This is represented by a SchemaQuery object; see that typedef for details.
5080 : *
5081 : * See top of file for examples of both kinds of query.
5082 : *
5083 : * In addition to the query itself, we accept a null-terminated array of
5084 : * literal keywords, which will be returned if they match the input-so-far
5085 : * (case insensitively). (These are in addition to keywords specified
5086 : * within the schema_query, if any.)
5087 : *
5088 : * If "verbatim" is true, then we use the given text as-is to match the
5089 : * query results; otherwise we parse it as a possibly-qualified identifier,
5090 : * and reconstruct suitable quoting afterward.
5091 : *
5092 : * "text" and "state" are supplied by Readline. "text" is the word we are
5093 : * trying to complete. "state" is zero on first call, nonzero later.
5094 : *
5095 : * readline will call this repeatedly with the same text and varying
5096 : * state. On each call, we are supposed to return a malloc'd string
5097 : * that is a candidate completion. Return NULL when done.
5098 : */
5099 : static char *
5100 CBC 281 : _complete_from_query(const char *simple_query,
5101 : const SchemaQuery *schema_query,
5102 : const char *const *keywords,
5103 ECB : bool verbatim,
5104 : const char *text, int state)
5105 : {
5106 : static int list_index,
5107 : num_schema_only,
5108 : num_query_other,
5109 : num_keywords;
5110 : static PGresult *result = NULL;
5111 : static bool non_empty_object;
5112 : static bool schemaquoted;
5113 : static bool objectquoted;
5114 :
5115 : /*
5116 : * If this is the first time for this completion, we fetch a list of our
5117 : * "things" from the backend.
5118 : */
5119 GIC 281 : if (state == 0)
5120 ECB : {
5121 : PQExpBufferData query_buffer;
5122 : char *schemaname;
5123 : char *objectname;
5124 : char *e_object_like;
5125 : char *e_schemaname;
5126 : char *e_ref_object;
5127 : char *e_ref_schema;
5128 :
5129 EUB : /* Reset static state, ensuring no memory leaks */
5130 GIC 44 : list_index = 0;
5131 GBC 44 : num_schema_only = 0;
5132 GIC 44 : num_query_other = 0;
5133 44 : num_keywords = 0;
5134 44 : PQclear(result);
5135 44 : result = NULL;
5136 :
5137 : /* Parse text, splitting into schema and object name if needed */
5138 44 : if (verbatim)
5139 : {
5140 CBC 8 : objectname = pg_strdup(text);
5141 GIC 8 : schemaname = NULL;
5142 : }
5143 ECB : else
5144 : {
5145 GIC 36 : parse_identifier(text,
5146 : &schemaname, &objectname,
5147 : &schemaquoted, &objectquoted);
5148 ECB : }
5149 :
5150 : /* Remember whether the user has typed anything in the object part */
5151 GIC 44 : non_empty_object = (*objectname != '\0');
5152 :
5153 ECB : /*
5154 EUB : * Convert objectname to a LIKE prefix pattern (e.g. 'foo%'), and set
5155 : * up suitably-escaped copies of all the strings we need.
5156 ECB : */
5157 GBC 44 : e_object_like = make_like_pattern(objectname);
5158 :
5159 CBC 44 : if (schemaname)
5160 GIC 3 : e_schemaname = escape_string(schemaname);
5161 : else
5162 41 : e_schemaname = NULL;
5163 :
5164 CBC 44 : if (completion_ref_object)
5165 GIC 21 : e_ref_object = escape_string(completion_ref_object);
5166 : else
5167 CBC 23 : e_ref_object = NULL;
5168 :
5169 GIC 44 : if (completion_ref_schema)
5170 1 : e_ref_schema = escape_string(completion_ref_schema);
5171 : else
5172 CBC 43 : e_ref_schema = NULL;
5173 :
5174 44 : initPQExpBuffer(&query_buffer);
5175 :
5176 GIC 44 : if (schema_query)
5177 ECB : {
5178 GBC 36 : Assert(simple_query == NULL);
5179 :
5180 ECB : /*
5181 EUB : * We issue different queries depending on whether the input is
5182 : * already qualified or not. schema_query gives us the pieces to
5183 ECB : * assemble.
5184 : */
5185 GIC 36 : if (schemaname == NULL || schema_query->namespace == NULL)
5186 : {
5187 : /* Get unqualified names matching the input-so-far */
5188 33 : appendPQExpBufferStr(&query_buffer, "SELECT ");
5189 33 : if (schema_query->use_distinct)
5190 UIC 0 : appendPQExpBufferStr(&query_buffer, "DISTINCT ");
5191 GIC 33 : appendPQExpBuffer(&query_buffer,
5192 : "%s, NULL::pg_catalog.text FROM %s",
5193 33 : schema_query->result,
5194 33 : schema_query->catname);
5195 33 : if (schema_query->refnamespace && completion_ref_schema)
5196 1 : appendPQExpBufferStr(&query_buffer,
5197 : ", pg_catalog.pg_namespace nr");
5198 33 : appendPQExpBufferStr(&query_buffer, " WHERE ");
5199 33 : if (schema_query->selcondition)
5200 33 : appendPQExpBuffer(&query_buffer, "%s AND ",
5201 33 : schema_query->selcondition);
5202 33 : appendPQExpBuffer(&query_buffer, "(%s) LIKE '%s'",
5203 33 : schema_query->result,
5204 : e_object_like);
5205 33 : if (schema_query->viscondition)
5206 15 : appendPQExpBuffer(&query_buffer, " AND %s",
5207 15 : schema_query->viscondition);
5208 33 : if (schema_query->refname)
5209 : {
5210 18 : Assert(completion_ref_object);
5211 18 : appendPQExpBuffer(&query_buffer, " AND %s = '%s'",
5212 18 : schema_query->refname, e_ref_object);
5213 18 : if (schema_query->refnamespace && completion_ref_schema)
5214 1 : appendPQExpBuffer(&query_buffer,
5215 : " AND %s = nr.oid AND nr.nspname = '%s'",
5216 1 : schema_query->refnamespace,
5217 : e_ref_schema);
5218 17 : else if (schema_query->refviscondition)
5219 17 : appendPQExpBuffer(&query_buffer,
5220 : " AND %s",
5221 17 : schema_query->refviscondition);
5222 : }
5223 :
5224 : /*
5225 : * When fetching relation names, suppress system catalogs
5226 : * unless the input-so-far begins with "pg_". This is a
5227 : * compromise between not offering system catalogs for
5228 : * completion at all, and having them swamp the result when
5229 : * the input is just "p".
5230 ECB : */
5231 GIC 33 : if (strcmp(schema_query->catname,
5232 14 : "pg_catalog.pg_class c") == 0 &&
5233 14 : strncmp(objectname, "pg_", 3) != 0)
5234 : {
5235 14 : appendPQExpBufferStr(&query_buffer,
5236 : " AND c.relnamespace <> (SELECT oid FROM"
5237 : " pg_catalog.pg_namespace WHERE nspname = 'pg_catalog')");
5238 : }
5239 :
5240 : /*
5241 : * If the target object type can be schema-qualified, add in
5242 : * schema names matching the input-so-far.
5243 : */
5244 33 : if (schema_query->namespace)
5245 : {
5246 15 : appendPQExpBuffer(&query_buffer, "\nUNION ALL\n"
5247 : "SELECT NULL::pg_catalog.text, n.nspname "
5248 : "FROM pg_catalog.pg_namespace n "
5249 ECB : "WHERE n.nspname LIKE '%s'",
5250 : e_object_like);
5251 :
5252 : /*
5253 : * Likewise, suppress system schemas unless the
5254 : * input-so-far begins with "pg_".
5255 : */
5256 GIC 15 : if (strncmp(objectname, "pg_", 3) != 0)
5257 15 : appendPQExpBufferStr(&query_buffer,
5258 : " AND n.nspname NOT LIKE E'pg\\\\_%'");
5259 :
5260 ECB : /*
5261 : * Since we're matching these schema names to the object
5262 : * name, handle their quoting using the object name's
5263 : * quoting state.
5264 : */
5265 CBC 15 : schemaquoted = objectquoted;
5266 : }
5267 : }
5268 ECB : else
5269 : {
5270 : /* Input is qualified, so produce only qualified names */
5271 CBC 3 : appendPQExpBufferStr(&query_buffer, "SELECT ");
5272 GIC 3 : if (schema_query->use_distinct)
5273 1 : appendPQExpBufferStr(&query_buffer, "DISTINCT ");
5274 3 : appendPQExpBuffer(&query_buffer, "%s, n.nspname "
5275 ECB : "FROM %s, pg_catalog.pg_namespace n",
5276 GIC 3 : schema_query->result,
5277 3 : schema_query->catname);
5278 3 : if (schema_query->refnamespace && completion_ref_schema)
5279 UIC 0 : appendPQExpBufferStr(&query_buffer,
5280 : ", pg_catalog.pg_namespace nr");
5281 CBC 3 : appendPQExpBuffer(&query_buffer, " WHERE %s = n.oid AND ",
5282 GIC 3 : schema_query->namespace);
5283 3 : if (schema_query->selcondition)
5284 3 : appendPQExpBuffer(&query_buffer, "%s AND ",
5285 3 : schema_query->selcondition);
5286 3 : appendPQExpBuffer(&query_buffer, "(%s) LIKE '%s' AND ",
5287 CBC 3 : schema_query->result,
5288 : e_object_like);
5289 3 : appendPQExpBuffer(&query_buffer, "n.nspname = '%s'",
5290 ECB : e_schemaname);
5291 GIC 3 : if (schema_query->refname)
5292 ECB : {
5293 GIC 1 : Assert(completion_ref_object);
5294 CBC 1 : appendPQExpBuffer(&query_buffer, " AND %s = '%s'",
5295 1 : schema_query->refname, e_ref_object);
5296 GIC 1 : if (schema_query->refnamespace && completion_ref_schema)
5297 LBC 0 : appendPQExpBuffer(&query_buffer,
5298 : " AND %s = nr.oid AND nr.nspname = '%s'",
5299 0 : schema_query->refnamespace,
5300 ECB : e_ref_schema);
5301 GIC 1 : else if (schema_query->refviscondition)
5302 LBC 0 : appendPQExpBuffer(&query_buffer,
5303 : " AND %s",
5304 0 : schema_query->refviscondition);
5305 : }
5306 ECB : }
5307 : }
5308 : else
5309 : {
5310 GIC 8 : Assert(simple_query);
5311 : /* simple_query is an sprintf-style format string */
5312 8 : appendPQExpBuffer(&query_buffer, simple_query,
5313 : e_object_like,
5314 : e_ref_object, e_ref_schema);
5315 ECB : }
5316 :
5317 : /* Limit the number of records in the result */
5318 CBC 44 : appendPQExpBuffer(&query_buffer, "\nLIMIT %d",
5319 ECB : completion_max_records);
5320 EUB :
5321 ECB : /* Finally, we can issue the query */
5322 GIC 44 : result = exec_query(query_buffer.data);
5323 ECB :
5324 : /* Clean up */
5325 CBC 44 : termPQExpBuffer(&query_buffer);
5326 GNC 44 : free(schemaname);
5327 44 : free(objectname);
5328 CBC 44 : free(e_object_like);
5329 GNC 44 : free(e_schemaname);
5330 44 : free(e_ref_object);
5331 44 : free(e_ref_schema);
5332 ECB : }
5333 :
5334 : /* Return the next result, if any, but not if the query failed */
5335 CBC 281 : if (result && PQresultStatus(result) == PGRES_TUPLES_OK)
5336 ECB : {
5337 : int nskip;
5338 :
5339 CBC 281 : while (list_index < PQntuples(result))
5340 : {
5341 212 : const char *item = NULL;
5342 GIC 212 : const char *nsp = NULL;
5343 ECB :
5344 CBC 212 : if (!PQgetisnull(result, list_index, 0))
5345 GIC 211 : item = PQgetvalue(result, list_index, 0);
5346 CBC 245 : if (PQnfields(result) > 1 &&
5347 GIC 33 : !PQgetisnull(result, list_index, 1))
5348 4 : nsp = PQgetvalue(result, list_index, 1);
5349 212 : list_index++;
5350 :
5351 : /* In verbatim mode, we return all the items as-is */
5352 212 : if (verbatim)
5353 : {
5354 181 : num_query_other++;
5355 181 : return pg_strdup(item);
5356 ECB : }
5357 :
5358 : /*
5359 : * In normal mode, a name requiring quoting will be returned only
5360 : * if the input was empty or quoted. Otherwise the user might see
5361 : * completion inserting a quote she didn't type, which is
5362 : * surprising. This restriction also dodges some odd behaviors of
5363 : * some versions of readline/libedit.
5364 : */
5365 GIC 31 : if (non_empty_object)
5366 : {
5367 26 : if (item && !objectquoted && identifier_needs_quotes(item))
5368 UIC 0 : continue;
5369 CBC 26 : if (nsp && !schemaquoted && identifier_needs_quotes(nsp))
5370 UIC 0 : continue;
5371 ECB : }
5372 :
5373 : /* Count schema-only results for hack below */
5374 GIC 31 : if (item == NULL && nsp != NULL)
5375 1 : num_schema_only++;
5376 : else
5377 30 : num_query_other++;
5378 :
5379 31 : return requote_identifier(nsp, item, schemaquoted, objectquoted);
5380 : }
5381 ECB :
5382 : /*
5383 : * When the query result is exhausted, check for hard-wired keywords.
5384 : * These will only be returned if they match the input-so-far,
5385 : * ignoring case.
5386 : */
5387 GIC 69 : nskip = list_index - PQntuples(result);
5388 69 : if (schema_query && schema_query->keywords)
5389 : {
5390 CBC 2 : const char *const *itemp = schema_query->keywords;
5391 :
5392 GIC 9 : while (*itemp)
5393 : {
5394 8 : const char *item = *itemp++;
5395 :
5396 CBC 8 : if (nskip-- > 0)
5397 1 : continue;
5398 7 : list_index++;
5399 7 : if (pg_strncasecmp(text, item, strlen(text)) == 0)
5400 : {
5401 1 : num_keywords++;
5402 1 : return pg_strdup_keyword_case(item, text);
5403 ECB : }
5404 EUB : }
5405 : }
5406 CBC 68 : if (keywords)
5407 ECB : {
5408 CBC 44 : const char *const *itemp = keywords;
5409 ECB :
5410 CBC 115 : while (*itemp)
5411 ECB : {
5412 CBC 95 : const char *item = *itemp++;
5413 :
5414 95 : if (nskip-- > 0)
5415 GIC 36 : continue;
5416 CBC 59 : list_index++;
5417 GIC 59 : if (pg_strncasecmp(text, item, strlen(text)) == 0)
5418 ECB : {
5419 CBC 24 : num_keywords++;
5420 24 : return pg_strdup_keyword_case(item, text);
5421 ECB : }
5422 EUB : }
5423 : }
5424 : }
5425 :
5426 ECB : /*
5427 EUB : * Hack: if we returned only bare schema names, don't let Readline add a
5428 : * space afterwards. Otherwise the schema will stop being part of the
5429 : * completion subject text, which is not what we want.
5430 : */
5431 GIC 44 : if (num_schema_only > 0 && num_query_other == 0 && num_keywords == 0)
5432 1 : rl_completion_append_character = '\0';
5433 :
5434 : /* No more matches, so free the result structure and return null */
5435 CBC 44 : PQclear(result);
5436 GIC 44 : result = NULL;
5437 CBC 44 : return NULL;
5438 : }
5439 :
5440 :
5441 : /*
5442 : * Set up completion_ref_object and completion_ref_schema
5443 ECB : * by parsing the given word. These variables can then be
5444 : * used in a query passed to _complete_from_query.
5445 : */
5446 : static void
5447 CBC 19 : set_completion_reference(const char *word)
5448 : {
5449 : bool schemaquoted,
5450 ECB : objectquoted;
5451 :
5452 CBC 19 : parse_identifier(word,
5453 ECB : &completion_ref_schema, &completion_ref_object,
5454 : &schemaquoted, &objectquoted);
5455 CBC 19 : }
5456 ECB :
5457 : /*
5458 : * Set up completion_ref_object when it should just be
5459 : * the given word verbatim.
5460 : */
5461 : static void
5462 GIC 2 : set_completion_reference_verbatim(const char *word)
5463 : {
5464 CBC 2 : completion_ref_schema = NULL;
5465 GIC 2 : completion_ref_object = pg_strdup(word);
5466 CBC 2 : }
5467 ECB :
5468 :
5469 : /*
5470 : * This function returns in order one of a fixed, NULL pointer terminated list
5471 : * of strings (if matching). This can be used if there are only a fixed number
5472 : * SQL words that can appear at certain spot.
5473 : */
5474 : static char *
5475 GIC 30 : complete_from_list(const char *text, int state)
5476 : {
5477 ECB : static int string_length,
5478 : list_index,
5479 : matches;
5480 : static bool casesensitive;
5481 : const char *item;
5482 :
5483 : /* need to have a list */
5484 GIC 30 : Assert(completion_charpp != NULL);
5485 :
5486 : /* Initialization */
5487 30 : if (state == 0)
5488 : {
5489 12 : list_index = 0;
5490 CBC 12 : string_length = strlen(text);
5491 GIC 12 : casesensitive = completion_case_sensitive;
5492 CBC 12 : matches = 0;
5493 EUB : }
5494 ECB :
5495 GBC 462 : while ((item = completion_charpp[list_index++]))
5496 : {
5497 : /* First pass is case sensitive */
5498 GIC 419 : if (casesensitive && strncmp(text, item, string_length) == 0)
5499 ECB : {
5500 CBC 3 : matches++;
5501 GIC 3 : return pg_strdup(item);
5502 ECB : }
5503 :
5504 : /* Second pass is case insensitive, don't bother counting matches */
5505 GIC 416 : if (!casesensitive && pg_strncasecmp(text, item, string_length) == 0)
5506 : {
5507 14 : if (completion_case_sensitive)
5508 1 : return pg_strdup(item);
5509 : else
5510 :
5511 : /*
5512 ECB : * If case insensitive matching was requested initially,
5513 : * adjust the case according to setting.
5514 : */
5515 CBC 13 : return pg_strdup_keyword_case(item, text);
5516 : }
5517 ECB : }
5518 :
5519 : /*
5520 : * No matches found. If we're not case insensitive already, lets switch to
5521 : * being case insensitive and try again
5522 : */
5523 CBC 13 : if (casesensitive && matches == 0)
5524 ECB : {
5525 GIC 1 : casesensitive = false;
5526 CBC 1 : list_index = 0;
5527 1 : state++;
5528 GIC 1 : return complete_from_list(text, state);
5529 : }
5530 :
5531 ECB : /* If no more matches, return null. */
5532 GIC 12 : return NULL;
5533 ECB : }
5534 :
5535 :
5536 : /*
5537 : * This function returns one fixed string the first time even if it doesn't
5538 : * match what's there, and nothing the second time. The string
5539 : * to be used must be in completion_charp.
5540 : *
5541 : * If the given string is "", this has the effect of preventing readline
5542 : * from doing any completion. (Without this, readline tries to do filename
5543 : * completion which is seldom the right thing.)
5544 : *
5545 : * If the given string is not empty, readline will replace whatever the
5546 : * user typed with that string. This behavior might be useful if it's
5547 : * completely certain that we know what must appear at a certain spot,
5548 : * so that it's okay to overwrite misspellings. In practice, given the
5549 : * relatively lame parsing technology used in this file, the level of
5550 : * certainty is seldom that high, so that you probably don't want to
5551 : * use this. Use complete_from_list with a one-element list instead;
5552 : * that won't try to auto-correct "misspellings".
5553 : */
5554 : static char *
5555 GIC 4 : complete_from_const(const char *text, int state)
5556 ECB : {
5557 CBC 4 : Assert(completion_charp != NULL);
5558 GIC 4 : if (state == 0)
5559 : {
5560 CBC 2 : if (completion_case_sensitive)
5561 2 : return pg_strdup(completion_charp);
5562 ECB : else
5563 :
5564 : /*
5565 : * If case insensitive matching was requested initially, adjust
5566 : * the case according to setting.
5567 : */
5568 UIC 0 : return pg_strdup_keyword_case(completion_charp, text);
5569 : }
5570 : else
5571 GIC 2 : return NULL;
5572 ECB : }
5573 :
5574 :
5575 : /*
5576 : * This function appends the variable name with prefix and suffix to
5577 : * the variable names array.
5578 : */
5579 : static void
5580 CBC 75 : append_variable_names(char ***varnames, int *nvars,
5581 : int *maxvars, const char *varname,
5582 : const char *prefix, const char *suffix)
5583 : {
5584 GIC 75 : if (*nvars >= *maxvars)
5585 : {
5586 UIC 0 : *maxvars *= 2;
5587 LBC 0 : *varnames = (char **) pg_realloc(*varnames,
5588 UIC 0 : ((*maxvars) + 1) * sizeof(char *));
5589 ECB : }
5590 :
5591 CBC 75 : (*varnames)[(*nvars)++] = psprintf("%s%s%s", prefix, varname, suffix);
5592 GIC 75 : }
5593 :
5594 :
5595 : /*
5596 : * This function supports completion with the name of a psql variable.
5597 : * The variable names can be prefixed and suffixed with additional text
5598 : * to support quoting usages. If need_value is true, only variables
5599 : * that are currently set are included; otherwise, special variables
5600 ECB : * (those that have hooks) are included even if currently unset.
5601 : */
5602 : static char **
5603 GIC 2 : complete_from_variables(const char *text, const char *prefix, const char *suffix,
5604 : bool need_value)
5605 : {
5606 : char **matches;
5607 : char **varnames;
5608 2 : int nvars = 0;
5609 CBC 2 : int maxvars = 100;
5610 : int i;
5611 : struct _variable *ptr;
5612 ECB :
5613 GIC 2 : varnames = (char **) pg_malloc((maxvars + 1) * sizeof(char *));
5614 ECB :
5615 CBC 78 : for (ptr = pset.vars->next; ptr; ptr = ptr->next)
5616 ECB : {
5617 CBC 76 : if (need_value && !(ptr->value))
5618 GIC 1 : continue;
5619 75 : append_variable_names(&varnames, &nvars, &maxvars, ptr->name,
5620 ECB : prefix, suffix);
5621 : }
5622 :
5623 CBC 2 : varnames[nvars] = NULL;
5624 GIC 2 : COMPLETE_WITH_LIST_CS((const char *const *) varnames);
5625 ECB :
5626 CBC 77 : for (i = 0; i < nvars; i++)
5627 GIC 75 : free(varnames[i]);
5628 2 : free(varnames);
5629 :
5630 CBC 2 : return matches;
5631 : }
5632 ECB :
5633 :
5634 : /*
5635 : * This function wraps rl_filename_completion_function() to strip quotes from
5636 : * the input before searching for matches and to quote any matches for which
5637 : * the consuming command will require it.
5638 : *
5639 : * Caller must set completion_charp to a zero- or one-character string
5640 : * containing the escape character. This is necessary since \copy has no
5641 : * escape character, but every other backslash command recognizes "\" as an
5642 : * escape character.
5643 : *
5644 : * Caller must also set completion_force_quote to indicate whether to force
5645 : * quotes around the result. (The SQL COPY command requires that.)
5646 : */
5647 : static char *
5648 CBC 16 : complete_from_files(const char *text, int state)
5649 : {
5650 ECB : #ifdef USE_FILENAME_QUOTING_FUNCTIONS
5651 :
5652 : /*
5653 : * If we're using a version of Readline that supports filename quoting
5654 : * hooks, rely on those, and invoke rl_filename_completion_function()
5655 : * without messing with its arguments. Readline does stuff internally
5656 : * that does not work well at all if we try to handle dequoting here.
5657 : * Instead, Readline will call quote_file_name() and dequote_file_name()
5658 : * (see below) at appropriate times.
5659 : *
5660 : * ... or at least, mostly it will. There are some paths involving
5661 : * unmatched file names in which Readline never calls quote_file_name(),
5662 : * and if left to its own devices it will incorrectly append a quote
5663 : * anyway. Set rl_completion_suppress_quote to prevent that. If we do
5664 : * get to quote_file_name(), we'll clear this again. (Yes, this seems
5665 : * like it's working around Readline bugs.)
5666 : */
5667 : #ifdef HAVE_RL_COMPLETION_SUPPRESS_QUOTE
5668 GIC 16 : rl_completion_suppress_quote = 1;
5669 : #endif
5670 :
5671 : /* If user typed a quote, force quoting (never remove user's quote) */
5672 16 : if (*text == '\'')
5673 UIC 0 : completion_force_quote = true;
5674 :
5675 GIC 16 : return rl_filename_completion_function(text, state);
5676 : #else
5677 :
5678 : /*
5679 : * Otherwise, we have to do the best we can.
5680 ECB : */
5681 : static const char *unquoted_text;
5682 : char *unquoted_match;
5683 : char *ret = NULL;
5684 :
5685 : /* If user typed a quote, force quoting (never remove user's quote) */
5686 : if (*text == '\'')
5687 : completion_force_quote = true;
5688 :
5689 : if (state == 0)
5690 : {
5691 : /* Initialization: stash the unquoted input. */
5692 : unquoted_text = strtokx(text, "", NULL, "'", *completion_charp,
5693 EUB : false, true, pset.encoding);
5694 : /* expect a NULL return for the empty string only */
5695 : if (!unquoted_text)
5696 ECB : {
5697 : Assert(*text == '\0');
5698 : unquoted_text = text;
5699 : }
5700 : }
5701 :
5702 : unquoted_match = rl_filename_completion_function(unquoted_text, state);
5703 : if (unquoted_match)
5704 : {
5705 : struct stat statbuf;
5706 : bool is_dir = (stat(unquoted_match, &statbuf) == 0 &&
5707 : S_ISDIR(statbuf.st_mode) != 0);
5708 :
5709 : /* Re-quote the result, if needed. */
5710 : ret = quote_if_needed(unquoted_match, " \t\r\n\"`",
5711 EUB : '\'', *completion_charp,
5712 : completion_force_quote,
5713 : pset.encoding);
5714 : if (ret)
5715 : free(unquoted_match);
5716 ECB : else
5717 : ret = unquoted_match;
5718 :
5719 : /*
5720 : * If it's a directory, replace trailing quote with a slash; this is
5721 : * usually more convenient. (If we didn't quote, leave this to
5722 : * libedit.)
5723 : */
5724 : if (*ret == '\'' && is_dir)
5725 : {
5726 : char *retend = ret + strlen(ret) - 1;
5727 :
5728 : Assert(*retend == '\'');
5729 : *retend = '/';
5730 : /* Prevent libedit from adding a space, too */
5731 : rl_completion_append_character = '\0';
5732 : }
5733 : }
5734 :
5735 : return ret;
5736 : #endif /* USE_FILENAME_QUOTING_FUNCTIONS */
5737 : }
5738 :
5739 :
5740 : /* HELPER FUNCTIONS */
5741 :
5742 :
5743 : /*
5744 : * Make a pg_strdup copy of s and convert the case according to
5745 : * COMP_KEYWORD_CASE setting, using ref as the text that was already entered.
5746 : */
5747 : static char *
5748 CBC 40 : pg_strdup_keyword_case(const char *s, const char *ref)
5749 ECB : {
5750 : char *ret,
5751 : *p;
5752 CBC 40 : unsigned char first = ref[0];
5753 ECB :
5754 GIC 40 : ret = pg_strdup(s);
5755 ECB :
5756 GIC 40 : if (pset.comp_case == PSQL_COMP_CASE_LOWER ||
5757 34 : ((pset.comp_case == PSQL_COMP_CASE_PRESERVE_LOWER ||
5758 34 : pset.comp_case == PSQL_COMP_CASE_PRESERVE_UPPER) && islower(first)) ||
5759 26 : (pset.comp_case == PSQL_COMP_CASE_PRESERVE_LOWER && !isalpha(first)))
5760 : {
5761 122 : for (p = ret; *p; p++)
5762 108 : *p = pg_tolower((unsigned char) *p);
5763 : }
5764 : else
5765 : {
5766 241 : for (p = ret; *p; p++)
5767 215 : *p = pg_toupper((unsigned char) *p);
5768 : }
5769 :
5770 40 : return ret;
5771 : }
5772 :
5773 ECB :
5774 : /*
5775 : * escape_string - Escape argument for use as string literal.
5776 : *
5777 : * The returned value has to be freed.
5778 : */
5779 : static char *
5780 GIC 71 : escape_string(const char *text)
5781 : {
5782 : size_t text_length;
5783 : char *result;
5784 :
5785 71 : text_length = strlen(text);
5786 :
5787 71 : result = pg_malloc(text_length * 2 + 1);
5788 71 : PQescapeStringConn(pset.db, result, text, text_length, NULL);
5789 :
5790 71 : return result;
5791 : }
5792 :
5793 ECB :
5794 : /*
5795 : * make_like_pattern - Convert argument to a LIKE prefix pattern.
5796 : *
5797 : * We escape _ and % in the given text by backslashing, append a % to
5798 EUB : * represent "any subsequent characters", and then pass the string through
5799 : * escape_string() so it's ready to insert in a query. The result needs
5800 ECB : * to be freed.
5801 : */
5802 : static char *
5803 GIC 44 : make_like_pattern(const char *word)
5804 : {
5805 : char *result;
5806 44 : char *buffer = pg_malloc(strlen(word) * 2 + 2);
5807 44 : char *bptr = buffer;
5808 :
5809 180 : while (*word)
5810 : {
5811 136 : if (*word == '_' || *word == '%')
5812 2 : *bptr++ = '\\';
5813 136 : if (IS_HIGHBIT_SET(*word))
5814 : {
5815 : /*
5816 : * Transfer multibyte characters without further processing, to
5817 : * avoid getting confused in unsafe client encodings.
5818 : */
5819 UIC 0 : int chlen = PQmblenBounded(word, pset.encoding);
5820 :
5821 0 : while (chlen-- > 0)
5822 0 : *bptr++ = *word++;
5823 : }
5824 : else
5825 GIC 136 : *bptr++ = *word++;
5826 : }
5827 44 : *bptr++ = '%';
5828 44 : *bptr = '\0';
5829 :
5830 44 : result = escape_string(buffer);
5831 44 : free(buffer);
5832 44 : return result;
5833 : }
5834 :
5835 :
5836 : /*
5837 : * parse_identifier - Parse a possibly-schema-qualified SQL identifier.
5838 : *
5839 : * This involves splitting off the schema name if present, de-quoting,
5840 : * and downcasing any unquoted text. We are a bit laxer than the backend
5841 : * in that we allow just portions of a name to be quoted --- that's because
5842 : * psql metacommands have traditionally behaved that way.
5843 : *
5844 : * Outputs are a malloc'd schema name (NULL if none), malloc'd object name,
5845 : * and booleans telling whether any part of the schema and object name was
5846 : * double-quoted.
5847 : */
5848 : static void
5849 55 : parse_identifier(const char *ident,
5850 : char **schemaname, char **objectname,
5851 : bool *schemaquoted, bool *objectquoted)
5852 : {
5853 55 : size_t buflen = strlen(ident) + 1;
5854 55 : bool enc_is_single_byte = (pg_encoding_max_length(pset.encoding) == 1);
5855 : char *sname;
5856 : char *oname;
5857 : char *optr;
5858 : bool inquotes;
5859 :
5860 : /* Initialize, making a certainly-large-enough output buffer */
5861 55 : sname = NULL;
5862 55 : oname = pg_malloc(buflen);
5863 55 : *schemaquoted = *objectquoted = false;
5864 : /* Scan */
5865 55 : optr = oname;
5866 55 : inquotes = false;
5867 268 : while (*ident)
5868 : {
5869 213 : unsigned char ch = (unsigned char) *ident++;
5870 :
5871 213 : if (ch == '"')
5872 : {
5873 CBC 7 : if (inquotes && *ident == '"')
5874 : {
5875 : /* two quote marks within a quoted identifier = emit quote */
5876 UIC 0 : *optr++ = '"';
5877 LBC 0 : ident++;
5878 : }
5879 ECB : else
5880 : {
5881 CBC 7 : inquotes = !inquotes;
5882 7 : *objectquoted = true;
5883 ECB : }
5884 : }
5885 GIC 206 : else if (ch == '.' && !inquotes)
5886 ECB : {
5887 : /* Found a schema name, transfer it to sname / *schemaquoted */
5888 GIC 4 : *optr = '\0';
5889 4 : free(sname); /* drop any catalog name */
5890 4 : sname = oname;
5891 CBC 4 : oname = pg_malloc(buflen);
5892 4 : optr = oname;
5893 GIC 4 : *schemaquoted = *objectquoted;
5894 4 : *objectquoted = false;
5895 ECB : }
5896 GIC 202 : else if (!enc_is_single_byte && IS_HIGHBIT_SET(ch))
5897 UIC 0 : {
5898 : /*
5899 : * Transfer multibyte characters without further processing. They
5900 : * wouldn't be affected by our downcasing rule anyway, and this
5901 : * avoids possibly doing the wrong thing in unsafe client
5902 : * encodings.
5903 : */
5904 0 : int chlen = PQmblenBounded(ident - 1, pset.encoding);
5905 ECB :
5906 UIC 0 : *optr++ = (char) ch;
5907 0 : while (--chlen > 0)
5908 0 : *optr++ = *ident++;
5909 : }
5910 ECB : else
5911 : {
5912 CBC 202 : if (!inquotes)
5913 ECB : {
5914 : /*
5915 : * This downcasing transformation should match the backend's
5916 : * downcase_identifier() as best we can. We do not know the
5917 : * backend's locale, though, so it's necessarily approximate.
5918 : * We assume that psql is operating in the same locale and
5919 : * encoding as the backend.
5920 : */
5921 GIC 178 : if (ch >= 'A' && ch <= 'Z')
5922 28 : ch += 'a' - 'A';
5923 150 : else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
5924 UIC 0 : ch = tolower(ch);
5925 : }
5926 GIC 202 : *optr++ = (char) ch;
5927 : }
5928 ECB : }
5929 :
5930 GIC 55 : *optr = '\0';
5931 CBC 55 : *schemaname = sname;
5932 55 : *objectname = oname;
5933 GIC 55 : }
5934 ECB :
5935 :
5936 : /*
5937 : * requote_identifier - Reconstruct a possibly-schema-qualified SQL identifier.
5938 : *
5939 : * Build a malloc'd string containing the identifier, with quoting applied
5940 : * as necessary. This is more or less the inverse of parse_identifier;
5941 : * in particular, if an input component was quoted, we'll quote the output
5942 : * even when that isn't strictly required.
5943 : *
5944 EUB : * Unlike parse_identifier, we handle the case where a schema and no
5945 : * object name is provided, producing just "schema.".
5946 : */
5947 : static char *
5948 GIC 31 : requote_identifier(const char *schemaname, const char *objectname,
5949 : bool quote_schema, bool quote_object)
5950 ECB : {
5951 : char *result;
5952 CBC 31 : size_t buflen = 1; /* count the trailing \0 */
5953 ECB : char *ptr;
5954 :
5955 : /*
5956 : * We could use PQescapeIdentifier for some of this, but not all, and it
5957 : * adds more notational cruft than it seems worth.
5958 : */
5959 GIC 31 : if (schemaname)
5960 : {
5961 4 : buflen += strlen(schemaname) + 1; /* +1 for the dot */
5962 4 : if (!quote_schema)
5963 4 : quote_schema = identifier_needs_quotes(schemaname);
5964 4 : if (quote_schema)
5965 : {
5966 UIC 0 : buflen += 2; /* account for quote marks */
5967 0 : for (const char *p = schemaname; *p; p++)
5968 : {
5969 0 : if (*p == '"')
5970 0 : buflen++;
5971 : }
5972 : }
5973 : }
5974 CBC 31 : if (objectname)
5975 : {
5976 GIC 30 : buflen += strlen(objectname);
5977 30 : if (!quote_object)
5978 CBC 22 : quote_object = identifier_needs_quotes(objectname);
5979 30 : if (quote_object)
5980 : {
5981 GIC 8 : buflen += 2; /* account for quote marks */
5982 73 : for (const char *p = objectname; *p; p++)
5983 : {
5984 65 : if (*p == '"')
5985 UIC 0 : buflen++;
5986 ECB : }
5987 : }
5988 : }
5989 GIC 31 : result = pg_malloc(buflen);
5990 CBC 31 : ptr = result;
5991 31 : if (schemaname)
5992 ECB : {
5993 GIC 4 : if (quote_schema)
5994 LBC 0 : *ptr++ = '"';
5995 GIC 28 : for (const char *p = schemaname; *p; p++)
5996 ECB : {
5997 GIC 24 : *ptr++ = *p;
5998 CBC 24 : if (*p == '"')
5999 UIC 0 : *ptr++ = '"';
6000 : }
6001 GBC 4 : if (quote_schema)
6002 UBC 0 : *ptr++ = '"';
6003 GIC 4 : *ptr++ = '.';
6004 : }
6005 31 : if (objectname)
6006 ECB : {
6007 CBC 30 : if (quote_object)
6008 GIC 8 : *ptr++ = '"';
6009 264 : for (const char *p = objectname; *p; p++)
6010 ECB : {
6011 GIC 234 : *ptr++ = *p;
6012 234 : if (*p == '"')
6013 LBC 0 : *ptr++ = '"';
6014 ECB : }
6015 CBC 30 : if (quote_object)
6016 8 : *ptr++ = '"';
6017 ECB : }
6018 CBC 31 : *ptr = '\0';
6019 31 : return result;
6020 : }
6021 ECB :
6022 EUB :
6023 : /*
6024 : * Detect whether an identifier must be double-quoted.
6025 : *
6026 : * Note we'll quote anything that's not ASCII; the backend's quote_ident()
6027 : * does the same. Perhaps this could be relaxed in future.
6028 : */
6029 : static bool
6030 GIC 46 : identifier_needs_quotes(const char *ident)
6031 EUB : {
6032 : int kwnum;
6033 :
6034 : /* Check syntax. */
6035 GIC 46 : if (!((ident[0] >= 'a' && ident[0] <= 'z') || ident[0] == '_'))
6036 UIC 0 : return true;
6037 CBC 46 : if (strspn(ident, "abcdefghijklmnopqrstuvwxyz0123456789_") != strlen(ident))
6038 UIC 0 : return true;
6039 :
6040 : /*
6041 : * Check for keyword. We quote keywords except for unreserved ones.
6042 : *
6043 : * It is possible that our keyword list doesn't quite agree with the
6044 : * server's, but this should be close enough for tab-completion purposes.
6045 : *
6046 ECB : * Note: ScanKeywordLookup() does case-insensitive comparison, but that's
6047 : * fine, since we already know we have all-lower-case.
6048 : */
6049 GBC 46 : kwnum = ScanKeywordLookup(ident, &ScanKeywords);
6050 :
6051 CBC 46 : if (kwnum >= 0 && ScanKeywordCategories[kwnum] != UNRESERVED_KEYWORD)
6052 UIC 0 : return true;
6053 :
6054 GIC 46 : return false;
6055 ECB : }
6056 :
6057 :
6058 : /*
6059 : * Execute a query, returning NULL if there was any error.
6060 : * This should be the preferred way of talking to the database in this file.
6061 : */
6062 : static PGresult *
6063 GIC 46 : exec_query(const char *query)
6064 : {
6065 : PGresult *result;
6066 :
6067 46 : if (query == NULL || !pset.db || PQstatus(pset.db) != CONNECTION_OK)
6068 UIC 0 : return NULL;
6069 :
6070 GIC 46 : result = PQexec(pset.db, query);
6071 :
6072 46 : if (PQresultStatus(result) != PGRES_TUPLES_OK)
6073 ECB : {
6074 : /*
6075 : * Printing an error while the user is typing would be quite annoying,
6076 : * so we don't. This does complicate debugging of this code; but you
6077 : * can look in the server log instead.
6078 : */
6079 : #ifdef NOT_USED
6080 : pg_log_error("tab completion query failed: %s\nQuery was:\n%s",
6081 : PQerrorMessage(pset.db), query);
6082 : #endif
6083 UIC 0 : PQclear(result);
6084 LBC 0 : result = NULL;
6085 : }
6086 ECB :
6087 CBC 46 : return result;
6088 ECB : }
6089 :
6090 :
6091 EUB : /*
6092 : * Parse all the word(s) before point.
6093 : *
6094 : * Returns a malloc'd array of character pointers that point into the malloc'd
6095 : * data array returned to *buffer; caller must free() both of these when done.
6096 : * *nwords receives the number of words found, ie, the valid length of the
6097 : * return array.
6098 : *
6099 ECB : * Words are returned right to left, that is, previous_words[0] gets the last
6100 : * word before point, previous_words[1] the next-to-last, etc.
6101 : */
6102 : static char **
6103 CBC 66 : get_previous_words(int point, char **buffer, int *nwords)
6104 ECB : {
6105 : char **previous_words;
6106 : char *buf;
6107 : char *outptr;
6108 GIC 66 : int words_found = 0;
6109 ECB : int i;
6110 EUB :
6111 : /*
6112 : * If we have anything in tab_completion_query_buf, paste it together with
6113 : * rl_line_buffer to construct the full query. Otherwise we can just use
6114 ECB : * rl_line_buffer as the input string.
6115 : */
6116 CBC 66 : if (tab_completion_query_buf && tab_completion_query_buf->len > 0)
6117 : {
6118 3 : i = tab_completion_query_buf->len;
6119 GBC 3 : buf = pg_malloc(point + i + 2);
6120 CBC 3 : memcpy(buf, tab_completion_query_buf->data, i);
6121 GIC 3 : buf[i++] = '\n';
6122 CBC 3 : memcpy(buf + i, rl_line_buffer, point);
6123 3 : i += point;
6124 GBC 3 : buf[i] = '\0';
6125 : /* Readjust point to reference appropriate offset in buf */
6126 CBC 3 : point = i;
6127 EUB : }
6128 ECB : else
6129 GIC 63 : buf = rl_line_buffer;
6130 ECB :
6131 : /*
6132 : * Allocate an array of string pointers and a buffer to hold the strings
6133 : * themselves. The worst case is that the line contains only
6134 : * non-whitespace WORD_BREAKS characters, making each one a separate word.
6135 : * This is usually much more space than we need, but it's cheaper than
6136 : * doing a separate malloc() for each word.
6137 : */
6138 GBC 66 : previous_words = (char **) pg_malloc(point * sizeof(char *));
6139 GIC 66 : *buffer = outptr = (char *) pg_malloc(point * 2);
6140 ECB :
6141 : /*
6142 : * First we look for a non-word char before the current point. (This is
6143 : * probably useless, if readline is on the same page as we are about what
6144 : * is a word, but if so it's cheap.)
6145 : */
6146 GIC 72 : for (i = point - 1; i >= 0; i--)
6147 : {
6148 69 : if (strchr(WORD_BREAKS, buf[i]))
6149 63 : break;
6150 : }
6151 66 : point = i;
6152 :
6153 : /*
6154 : * Now parse words, working backwards, until we hit start of line. The
6155 ECB : * backwards scan has some interesting but intentional properties
6156 : * concerning parenthesis handling.
6157 : */
6158 GIC 253 : while (point >= 0)
6159 : {
6160 ECB : int start,
6161 EUB : end;
6162 CBC 187 : bool inquotes = false;
6163 GBC 187 : int parentheses = 0;
6164 :
6165 : /* now find the first non-space which then constitutes the end */
6166 GIC 187 : end = -1;
6167 380 : for (i = point; i >= 0; i--)
6168 : {
6169 380 : if (!isspace((unsigned char) buf[i]))
6170 : {
6171 187 : end = i;
6172 187 : break;
6173 : }
6174 ECB : }
6175 : /* if no end found, we're done */
6176 CBC 187 : if (end < 0)
6177 UBC 0 : break;
6178 :
6179 ECB : /*
6180 : * Otherwise we now look for the start. The start is either the last
6181 : * character before any word-break character going backwards from the
6182 : * end, or it's simply character 0. We also handle open quotes and
6183 : * parentheses.
6184 : */
6185 GIC 938 : for (start = end; start > 0; start--)
6186 : {
6187 875 : if (buf[start] == '"')
6188 CBC 2 : inquotes = !inquotes;
6189 GIC 875 : if (!inquotes)
6190 : {
6191 870 : if (buf[start] == ')')
6192 LBC 0 : parentheses++;
6193 GBC 870 : else if (buf[start] == '(')
6194 : {
6195 CBC 3 : if (--parentheses <= 0)
6196 GIC 3 : break;
6197 ECB : }
6198 GIC 867 : else if (parentheses == 0 &&
6199 867 : strchr(WORD_BREAKS, buf[start - 1]))
6200 121 : break;
6201 : }
6202 : }
6203 :
6204 : /* Return the word located at start to end inclusive */
6205 187 : previous_words[words_found++] = outptr;
6206 187 : i = end - start + 1;
6207 187 : memcpy(outptr, &buf[start], i);
6208 GBC 187 : outptr += i;
6209 187 : *outptr++ = '\0';
6210 :
6211 : /* Continue searching */
6212 CBC 187 : point = start - 1;
6213 : }
6214 :
6215 : /* Release parsing input workspace, if we made one above */
6216 GIC 66 : if (buf != rl_line_buffer)
6217 3 : free(buf);
6218 :
6219 66 : *nwords = words_found;
6220 66 : return previous_words;
6221 : }
6222 :
6223 : /*
6224 : * Look up the type for the GUC variable with the passed name.
6225 : *
6226 : * Returns NULL if the variable is unknown. Otherwise the returned string,
6227 : * containing the type, has to be freed.
6228 ECB : */
6229 : static char *
6230 GIC 2 : get_guctype(const char *varname)
6231 : {
6232 : PQExpBufferData query_buffer;
6233 ECB : char *e_varname;
6234 : PGresult *result;
6235 GIC 2 : char *guctype = NULL;
6236 :
6237 2 : e_varname = escape_string(varname);
6238 :
6239 2 : initPQExpBuffer(&query_buffer);
6240 2 : appendPQExpBuffer(&query_buffer,
6241 ECB : "SELECT vartype FROM pg_catalog.pg_settings "
6242 : "WHERE pg_catalog.lower(name) = pg_catalog.lower('%s')",
6243 : e_varname);
6244 :
6245 CBC 2 : result = exec_query(query_buffer.data);
6246 2 : termPQExpBuffer(&query_buffer);
6247 2 : free(e_varname);
6248 ECB :
6249 CBC 2 : if (PQresultStatus(result) == PGRES_TUPLES_OK && PQntuples(result) > 0)
6250 GIC 2 : guctype = pg_strdup(PQgetvalue(result, 0, 0));
6251 ECB :
6252 GIC 2 : PQclear(result);
6253 :
6254 CBC 2 : return guctype;
6255 : }
6256 :
6257 : #ifdef USE_FILENAME_QUOTING_FUNCTIONS
6258 :
6259 : /*
6260 : * Quote a filename according to SQL rules, returning a malloc'd string.
6261 : * completion_charp must point to escape character or '\0', and
6262 : * completion_force_quote must be set correctly, as per comments for
6263 ECB : * complete_from_files().
6264 : */
6265 : static char *
6266 GIC 5 : quote_file_name(char *fname, int match_type, char *quote_pointer)
6267 : {
6268 : char *s;
6269 : struct stat statbuf;
6270 :
6271 ECB : /* Quote if needed. */
6272 GIC 5 : s = quote_if_needed(fname, " \t\r\n\"`",
6273 CBC 5 : '\'', *completion_charp,
6274 ECB : completion_force_quote,
6275 : pset.encoding);
6276 CBC 5 : if (!s)
6277 GIC 2 : s = pg_strdup(fname);
6278 :
6279 : /*
6280 : * However, some of the time we have to strip the trailing quote from what
6281 : * we send back. Never strip the trailing quote if the user already typed
6282 : * one; otherwise, suppress the trailing quote if we have multiple/no
6283 ECB : * matches (because we don't want to add a quote if the input is seemingly
6284 : * unfinished), or if the input was already quoted (because Readline will
6285 : * do arguably-buggy things otherwise), or if the file does not exist, or
6286 : * if it's a directory.
6287 : */
6288 CBC 5 : if (*s == '\'' &&
6289 GIC 3 : completion_last_char != '\'' &&
6290 1 : (match_type != SINGLE_MATCH ||
6291 CBC 2 : (quote_pointer && *quote_pointer == '\'') ||
6292 1 : stat(fname, &statbuf) != 0 ||
6293 GIC 1 : S_ISDIR(statbuf.st_mode)))
6294 ECB : {
6295 GIC 2 : char *send = s + strlen(s) - 1;
6296 ECB :
6297 CBC 2 : Assert(*send == '\'');
6298 GIC 2 : *send = '\0';
6299 : }
6300 :
6301 ECB : /*
6302 EUB : * And now we can let Readline do its thing with possibly adding a quote
6303 : * on its own accord. (This covers some additional cases beyond those
6304 : * dealt with above.)
6305 : */
6306 : #ifdef HAVE_RL_COMPLETION_SUPPRESS_QUOTE
6307 GIC 5 : rl_completion_suppress_quote = 0;
6308 : #endif
6309 :
6310 ECB : /*
6311 : * If user typed a leading quote character other than single quote (i.e.,
6312 : * double quote), zap it, so that we replace it with the correct single
6313 : * quote.
6314 : */
6315 GIC 5 : if (quote_pointer && *quote_pointer != '\'')
6316 CBC 4 : *quote_pointer = '\0';
6317 EUB :
6318 CBC 5 : return s;
6319 : }
6320 ECB :
6321 : /*
6322 : * Dequote a filename, if it's quoted.
6323 : * completion_charp must point to escape character or '\0', as per
6324 : * comments for complete_from_files().
6325 : */
6326 : static char *
6327 GIC 12 : dequote_file_name(char *fname, int quote_char)
6328 : {
6329 : char *unquoted_fname;
6330 ECB :
6331 : /*
6332 : * If quote_char is set, it's not included in "fname". We have to add it
6333 : * or strtokx will not interpret the string correctly (notably, it won't
6334 : * recognize escapes).
6335 : */
6336 GIC 12 : if (quote_char == '\'')
6337 ECB : {
6338 GIC 6 : char *workspace = (char *) pg_malloc(strlen(fname) + 2);
6339 :
6340 6 : workspace[0] = quote_char;
6341 CBC 6 : strcpy(workspace + 1, fname);
6342 6 : unquoted_fname = strtokx(workspace, "", NULL, "'", *completion_charp,
6343 : false, true, pset.encoding);
6344 6 : free(workspace);
6345 ECB : }
6346 : else
6347 GIC 6 : unquoted_fname = strtokx(fname, "", NULL, "'", *completion_charp,
6348 : false, true, pset.encoding);
6349 :
6350 : /* expect a NULL return for the empty string only */
6351 12 : if (!unquoted_fname)
6352 : {
6353 UIC 0 : Assert(*fname == '\0');
6354 0 : unquoted_fname = fname;
6355 ECB : }
6356 :
6357 : /* readline expects a malloc'd result that it is to free */
6358 GIC 12 : return pg_strdup(unquoted_fname);
6359 : }
6360 ECB :
6361 : #endif /* USE_FILENAME_QUOTING_FUNCTIONS */
6362 :
6363 : #endif /* USE_READLINE */
|
