PostgreSQL Source Code  git master
describe.c
Go to the documentation of this file.
1 /*
2  * psql - the PostgreSQL interactive terminal
3  *
4  * Support for the various \d ("describe") commands. Note that the current
5  * expectation is that all functions in this file will succeed when working
6  * with servers of versions 9.2 and up. It's okay to omit irrelevant
7  * information for an old server, but not to fail outright. (But failing
8  * against a pre-9.2 server is allowed.)
9  *
10  * Copyright (c) 2000-2024, PostgreSQL Global Development Group
11  *
12  * src/bin/psql/describe.c
13  */
14 #include "postgres_fe.h"
15 
16 #include <ctype.h>
17 
18 #include "catalog/pg_am.h"
19 #include "catalog/pg_attribute_d.h"
20 #include "catalog/pg_cast_d.h"
21 #include "catalog/pg_class_d.h"
22 #include "catalog/pg_default_acl_d.h"
23 #include "common.h"
24 #include "common/logging.h"
25 #include "describe.h"
26 #include "fe_utils/mbprint.h"
27 #include "fe_utils/print.h"
28 #include "fe_utils/string_utils.h"
29 #include "settings.h"
30 #include "variables.h"
31 
32 static const char *map_typename_pattern(const char *pattern);
33 static bool describeOneTableDetails(const char *schemaname,
34  const char *relationname,
35  const char *oid,
36  bool verbose);
37 static void add_tablespace_footer(printTableContent *const cont, char relkind,
38  Oid tablespace, const bool newline);
39 static void add_role_attribute(PQExpBuffer buf, const char *const str);
40 static bool listTSParsersVerbose(const char *pattern);
41 static bool describeOneTSParser(const char *oid, const char *nspname,
42  const char *prsname);
43 static bool listTSConfigsVerbose(const char *pattern);
44 static bool describeOneTSConfig(const char *oid, const char *nspname,
45  const char *cfgname,
46  const char *pnspname, const char *prsname);
47 static void printACLColumn(PQExpBuffer buf, const char *colname);
48 static bool listOneExtensionContents(const char *extname, const char *oid);
49 static bool validateSQLNamePattern(PQExpBuffer buf, const char *pattern,
50  bool have_where, bool force_escape,
51  const char *schemavar, const char *namevar,
52  const char *altnamevar,
53  const char *visibilityrule,
54  bool *added_clause, int maxparts);
55 
56 
57 /*----------------
58  * Handlers for various slash commands displaying some sort of list
59  * of things in the database.
60  *
61  * Note: try to format the queries to look nice in -E output.
62  *----------------
63  */
64 
65 
66 /*
67  * \da
68  * Takes an optional regexp to select particular aggregates
69  */
70 bool
71 describeAggregates(const char *pattern, bool verbose, bool showSystem)
72 {
74  PGresult *res;
75  printQueryOpt myopt = pset.popt;
76 
78 
80  "SELECT n.nspname as \"%s\",\n"
81  " p.proname AS \"%s\",\n"
82  " pg_catalog.format_type(p.prorettype, NULL) AS \"%s\",\n"
83  " CASE WHEN p.pronargs = 0\n"
84  " THEN CAST('*' AS pg_catalog.text)\n"
85  " ELSE pg_catalog.pg_get_function_arguments(p.oid)\n"
86  " END AS \"%s\",\n",
87  gettext_noop("Schema"),
88  gettext_noop("Name"),
89  gettext_noop("Result data type"),
90  gettext_noop("Argument data types"));
91 
92  if (pset.sversion >= 110000)
94  " pg_catalog.obj_description(p.oid, 'pg_proc') as \"%s\"\n"
95  "FROM pg_catalog.pg_proc p\n"
96  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n"
97  "WHERE p.prokind = 'a'\n",
98  gettext_noop("Description"));
99  else
101  " pg_catalog.obj_description(p.oid, 'pg_proc') as \"%s\"\n"
102  "FROM pg_catalog.pg_proc p\n"
103  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n"
104  "WHERE p.proisagg\n",
105  gettext_noop("Description"));
106 
107  if (!showSystem && !pattern)
108  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
109  " AND n.nspname <> 'information_schema'\n");
110 
111  if (!validateSQLNamePattern(&buf, pattern, true, false,
112  "n.nspname", "p.proname", NULL,
113  "pg_catalog.pg_function_is_visible(p.oid)",
114  NULL, 3))
115  {
117  return false;
118  }
119 
120  appendPQExpBufferStr(&buf, "ORDER BY 1, 2, 4;");
121 
122  res = PSQLexec(buf.data);
124  if (!res)
125  return false;
126 
127  myopt.title = _("List of aggregate functions");
128  myopt.translate_header = true;
129 
130  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
131 
132  PQclear(res);
133  return true;
134 }
135 
136 /*
137  * \dA
138  * Takes an optional regexp to select particular access methods
139  */
140 bool
141 describeAccessMethods(const char *pattern, bool verbose)
142 {
144  PGresult *res;
145  printQueryOpt myopt = pset.popt;
146  static const bool translate_columns[] = {false, true, false, false};
147 
148  if (pset.sversion < 90600)
149  {
150  char sverbuf[32];
151 
152  pg_log_error("The server (version %s) does not support access methods.",
154  sverbuf, sizeof(sverbuf)));
155  return true;
156  }
157 
159 
161  "SELECT amname AS \"%s\",\n"
162  " CASE amtype"
163  " WHEN 'i' THEN '%s'"
164  " WHEN 't' THEN '%s'"
165  " END AS \"%s\"",
166  gettext_noop("Name"),
167  gettext_noop("Index"),
168  gettext_noop("Table"),
169  gettext_noop("Type"));
170 
171  if (verbose)
172  {
174  ",\n amhandler AS \"%s\",\n"
175  " pg_catalog.obj_description(oid, 'pg_am') AS \"%s\"",
176  gettext_noop("Handler"),
177  gettext_noop("Description"));
178  }
179 
181  "\nFROM pg_catalog.pg_am\n");
182 
183  if (!validateSQLNamePattern(&buf, pattern, false, false,
184  NULL, "amname", NULL,
185  NULL,
186  NULL, 1))
187  {
189  return false;
190  }
191 
192  appendPQExpBufferStr(&buf, "ORDER BY 1;");
193 
194  res = PSQLexec(buf.data);
196  if (!res)
197  return false;
198 
199  myopt.title = _("List of access methods");
200  myopt.translate_header = true;
201  myopt.translate_columns = translate_columns;
202  myopt.n_translate_columns = lengthof(translate_columns);
203 
204  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
205 
206  PQclear(res);
207  return true;
208 }
209 
210 /*
211  * \db
212  * Takes an optional regexp to select particular tablespaces
213  */
214 bool
215 describeTablespaces(const char *pattern, bool verbose)
216 {
218  PGresult *res;
219  printQueryOpt myopt = pset.popt;
220 
222 
224  "SELECT spcname AS \"%s\",\n"
225  " pg_catalog.pg_get_userbyid(spcowner) AS \"%s\",\n"
226  " pg_catalog.pg_tablespace_location(oid) AS \"%s\"",
227  gettext_noop("Name"),
228  gettext_noop("Owner"),
229  gettext_noop("Location"));
230 
231  if (verbose)
232  {
233  appendPQExpBufferStr(&buf, ",\n ");
234  printACLColumn(&buf, "spcacl");
236  ",\n spcoptions AS \"%s\""
237  ",\n pg_catalog.pg_size_pretty(pg_catalog.pg_tablespace_size(oid)) AS \"%s\""
238  ",\n pg_catalog.shobj_description(oid, 'pg_tablespace') AS \"%s\"",
239  gettext_noop("Options"),
240  gettext_noop("Size"),
241  gettext_noop("Description"));
242  }
243 
245  "\nFROM pg_catalog.pg_tablespace\n");
246 
247  if (!validateSQLNamePattern(&buf, pattern, false, false,
248  NULL, "spcname", NULL,
249  NULL,
250  NULL, 1))
251  {
253  return false;
254  }
255 
256  appendPQExpBufferStr(&buf, "ORDER BY 1;");
257 
258  res = PSQLexec(buf.data);
260  if (!res)
261  return false;
262 
263  myopt.title = _("List of tablespaces");
264  myopt.translate_header = true;
265 
266  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
267 
268  PQclear(res);
269  return true;
270 }
271 
272 
273 /*
274  * \df
275  * Takes an optional regexp to select particular functions.
276  *
277  * As with \d, you can specify the kinds of functions you want:
278  *
279  * a for aggregates
280  * n for normal
281  * p for procedure
282  * t for trigger
283  * w for window
284  *
285  * and you can mix and match these in any order.
286  */
287 bool
288 describeFunctions(const char *functypes, const char *func_pattern,
289  char **arg_patterns, int num_arg_patterns,
290  bool verbose, bool showSystem)
291 {
292  bool showAggregate = strchr(functypes, 'a') != NULL;
293  bool showNormal = strchr(functypes, 'n') != NULL;
294  bool showProcedure = strchr(functypes, 'p') != NULL;
295  bool showTrigger = strchr(functypes, 't') != NULL;
296  bool showWindow = strchr(functypes, 'w') != NULL;
297  bool have_where;
299  PGresult *res;
300  printQueryOpt myopt = pset.popt;
301  static const bool translate_columns[] = {false, false, false, false, true, true, true, false, true, false, false, false, false};
302 
303  /* No "Parallel" column before 9.6 */
304  static const bool translate_columns_pre_96[] = {false, false, false, false, true, true, false, true, false, false, false, false};
305 
306  if (strlen(functypes) != strspn(functypes, "anptwS+"))
307  {
308  pg_log_error("\\df only takes [anptwS+] as options");
309  return true;
310  }
311 
312  if (showProcedure && pset.sversion < 110000)
313  {
314  char sverbuf[32];
315 
316  pg_log_error("\\df does not take a \"%c\" option with server version %s",
317  'p',
319  sverbuf, sizeof(sverbuf)));
320  return true;
321  }
322 
323  if (!showAggregate && !showNormal && !showProcedure && !showTrigger && !showWindow)
324  {
325  showAggregate = showNormal = showTrigger = showWindow = true;
326  if (pset.sversion >= 110000)
327  showProcedure = true;
328  }
329 
331 
333  "SELECT n.nspname as \"%s\",\n"
334  " p.proname as \"%s\",\n",
335  gettext_noop("Schema"),
336  gettext_noop("Name"));
337 
338  if (pset.sversion >= 110000)
340  " pg_catalog.pg_get_function_result(p.oid) as \"%s\",\n"
341  " pg_catalog.pg_get_function_arguments(p.oid) as \"%s\",\n"
342  " CASE p.prokind\n"
343  " WHEN 'a' THEN '%s'\n"
344  " WHEN 'w' THEN '%s'\n"
345  " WHEN 'p' THEN '%s'\n"
346  " ELSE '%s'\n"
347  " END as \"%s\"",
348  gettext_noop("Result data type"),
349  gettext_noop("Argument data types"),
350  /* translator: "agg" is short for "aggregate" */
351  gettext_noop("agg"),
352  gettext_noop("window"),
353  gettext_noop("proc"),
354  gettext_noop("func"),
355  gettext_noop("Type"));
356  else
358  " pg_catalog.pg_get_function_result(p.oid) as \"%s\",\n"
359  " pg_catalog.pg_get_function_arguments(p.oid) as \"%s\",\n"
360  " CASE\n"
361  " WHEN p.proisagg THEN '%s'\n"
362  " WHEN p.proiswindow THEN '%s'\n"
363  " WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN '%s'\n"
364  " ELSE '%s'\n"
365  " END as \"%s\"",
366  gettext_noop("Result data type"),
367  gettext_noop("Argument data types"),
368  /* translator: "agg" is short for "aggregate" */
369  gettext_noop("agg"),
370  gettext_noop("window"),
371  gettext_noop("trigger"),
372  gettext_noop("func"),
373  gettext_noop("Type"));
374 
375  if (verbose)
376  {
378  ",\n CASE\n"
379  " WHEN p.provolatile = 'i' THEN '%s'\n"
380  " WHEN p.provolatile = 's' THEN '%s'\n"
381  " WHEN p.provolatile = 'v' THEN '%s'\n"
382  " END as \"%s\"",
383  gettext_noop("immutable"),
384  gettext_noop("stable"),
385  gettext_noop("volatile"),
386  gettext_noop("Volatility"));
387  if (pset.sversion >= 90600)
389  ",\n CASE\n"
390  " WHEN p.proparallel = 'r' THEN '%s'\n"
391  " WHEN p.proparallel = 's' THEN '%s'\n"
392  " WHEN p.proparallel = 'u' THEN '%s'\n"
393  " END as \"%s\"",
394  gettext_noop("restricted"),
395  gettext_noop("safe"),
396  gettext_noop("unsafe"),
397  gettext_noop("Parallel"));
399  ",\n pg_catalog.pg_get_userbyid(p.proowner) as \"%s\""
400  ",\n CASE WHEN prosecdef THEN '%s' ELSE '%s' END AS \"%s\"",
401  gettext_noop("Owner"),
402  gettext_noop("definer"),
403  gettext_noop("invoker"),
404  gettext_noop("Security"));
405  appendPQExpBufferStr(&buf, ",\n ");
406  printACLColumn(&buf, "p.proacl");
408  ",\n l.lanname as \"%s\"",
409  gettext_noop("Language"));
411  ",\n CASE WHEN l.lanname IN ('internal', 'c') THEN p.prosrc END as \"%s\"",
412  gettext_noop("Internal name"));
414  ",\n pg_catalog.obj_description(p.oid, 'pg_proc') as \"%s\"",
415  gettext_noop("Description"));
416  }
417 
419  "\nFROM pg_catalog.pg_proc p"
420  "\n LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n");
421 
422  for (int i = 0; i < num_arg_patterns; i++)
423  {
425  " LEFT JOIN pg_catalog.pg_type t%d ON t%d.oid = p.proargtypes[%d]\n"
426  " LEFT JOIN pg_catalog.pg_namespace nt%d ON nt%d.oid = t%d.typnamespace\n",
427  i, i, i, i, i, i);
428  }
429 
430  if (verbose)
432  " LEFT JOIN pg_catalog.pg_language l ON l.oid = p.prolang\n");
433 
434  have_where = false;
435 
436  /* filter by function type, if requested */
437  if (showNormal && showAggregate && showProcedure && showTrigger && showWindow)
438  /* Do nothing */ ;
439  else if (showNormal)
440  {
441  if (!showAggregate)
442  {
443  if (have_where)
444  appendPQExpBufferStr(&buf, " AND ");
445  else
446  {
447  appendPQExpBufferStr(&buf, "WHERE ");
448  have_where = true;
449  }
450  if (pset.sversion >= 110000)
451  appendPQExpBufferStr(&buf, "p.prokind <> 'a'\n");
452  else
453  appendPQExpBufferStr(&buf, "NOT p.proisagg\n");
454  }
455  if (!showProcedure && pset.sversion >= 110000)
456  {
457  if (have_where)
458  appendPQExpBufferStr(&buf, " AND ");
459  else
460  {
461  appendPQExpBufferStr(&buf, "WHERE ");
462  have_where = true;
463  }
464  appendPQExpBufferStr(&buf, "p.prokind <> 'p'\n");
465  }
466  if (!showTrigger)
467  {
468  if (have_where)
469  appendPQExpBufferStr(&buf, " AND ");
470  else
471  {
472  appendPQExpBufferStr(&buf, "WHERE ");
473  have_where = true;
474  }
475  appendPQExpBufferStr(&buf, "p.prorettype <> 'pg_catalog.trigger'::pg_catalog.regtype\n");
476  }
477  if (!showWindow)
478  {
479  if (have_where)
480  appendPQExpBufferStr(&buf, " AND ");
481  else
482  {
483  appendPQExpBufferStr(&buf, "WHERE ");
484  have_where = true;
485  }
486  if (pset.sversion >= 110000)
487  appendPQExpBufferStr(&buf, "p.prokind <> 'w'\n");
488  else
489  appendPQExpBufferStr(&buf, "NOT p.proiswindow\n");
490  }
491  }
492  else
493  {
494  bool needs_or = false;
495 
496  appendPQExpBufferStr(&buf, "WHERE (\n ");
497  have_where = true;
498  /* Note: at least one of these must be true ... */
499  if (showAggregate)
500  {
501  if (pset.sversion >= 110000)
502  appendPQExpBufferStr(&buf, "p.prokind = 'a'\n");
503  else
504  appendPQExpBufferStr(&buf, "p.proisagg\n");
505  needs_or = true;
506  }
507  if (showTrigger)
508  {
509  if (needs_or)
510  appendPQExpBufferStr(&buf, " OR ");
512  "p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype\n");
513  needs_or = true;
514  }
515  if (showProcedure)
516  {
517  if (needs_or)
518  appendPQExpBufferStr(&buf, " OR ");
519  appendPQExpBufferStr(&buf, "p.prokind = 'p'\n");
520  needs_or = true;
521  }
522  if (showWindow)
523  {
524  if (needs_or)
525  appendPQExpBufferStr(&buf, " OR ");
526  if (pset.sversion >= 110000)
527  appendPQExpBufferStr(&buf, "p.prokind = 'w'\n");
528  else
529  appendPQExpBufferStr(&buf, "p.proiswindow\n");
530  }
531  appendPQExpBufferStr(&buf, " )\n");
532  }
533 
534  if (!validateSQLNamePattern(&buf, func_pattern, have_where, false,
535  "n.nspname", "p.proname", NULL,
536  "pg_catalog.pg_function_is_visible(p.oid)",
537  NULL, 3))
538  goto error_return;
539 
540  for (int i = 0; i < num_arg_patterns; i++)
541  {
542  if (strcmp(arg_patterns[i], "-") != 0)
543  {
544  /*
545  * Match type-name patterns against either internal or external
546  * name, like \dT. Unlike \dT, there seems no reason to
547  * discriminate against arrays or composite types.
548  */
549  char nspname[64];
550  char typname[64];
551  char ft[64];
552  char tiv[64];
553 
554  snprintf(nspname, sizeof(nspname), "nt%d.nspname", i);
555  snprintf(typname, sizeof(typname), "t%d.typname", i);
556  snprintf(ft, sizeof(ft),
557  "pg_catalog.format_type(t%d.oid, NULL)", i);
558  snprintf(tiv, sizeof(tiv),
559  "pg_catalog.pg_type_is_visible(t%d.oid)", i);
561  map_typename_pattern(arg_patterns[i]),
562  true, false,
563  nspname, typname, ft, tiv,
564  NULL, 3))
565  goto error_return;
566  }
567  else
568  {
569  /* "-" pattern specifies no such parameter */
570  appendPQExpBuffer(&buf, " AND t%d.typname IS NULL\n", i);
571  }
572  }
573 
574  if (!showSystem && !func_pattern)
575  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
576  " AND n.nspname <> 'information_schema'\n");
577 
578  appendPQExpBufferStr(&buf, "ORDER BY 1, 2, 4;");
579 
580  res = PSQLexec(buf.data);
582  if (!res)
583  return false;
584 
585  myopt.title = _("List of functions");
586  myopt.translate_header = true;
587  if (pset.sversion >= 90600)
588  {
589  myopt.translate_columns = translate_columns;
590  myopt.n_translate_columns = lengthof(translate_columns);
591  }
592  else
593  {
594  myopt.translate_columns = translate_columns_pre_96;
595  myopt.n_translate_columns = lengthof(translate_columns_pre_96);
596  }
597 
598  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
599 
600  PQclear(res);
601  return true;
602 
603 error_return:
605  return false;
606 }
607 
608 
609 
610 /*
611  * \dT
612  * describe types
613  */
614 bool
615 describeTypes(const char *pattern, bool verbose, bool showSystem)
616 {
618  PGresult *res;
619  printQueryOpt myopt = pset.popt;
620 
622 
624  "SELECT n.nspname as \"%s\",\n"
625  " pg_catalog.format_type(t.oid, NULL) AS \"%s\",\n",
626  gettext_noop("Schema"),
627  gettext_noop("Name"));
628  if (verbose)
629  {
631  " t.typname AS \"%s\",\n"
632  " CASE WHEN t.typrelid != 0\n"
633  " THEN CAST('tuple' AS pg_catalog.text)\n"
634  " WHEN t.typlen < 0\n"
635  " THEN CAST('var' AS pg_catalog.text)\n"
636  " ELSE CAST(t.typlen AS pg_catalog.text)\n"
637  " END AS \"%s\",\n"
638  " pg_catalog.array_to_string(\n"
639  " ARRAY(\n"
640  " SELECT e.enumlabel\n"
641  " FROM pg_catalog.pg_enum e\n"
642  " WHERE e.enumtypid = t.oid\n"
643  " ORDER BY e.enumsortorder\n"
644  " ),\n"
645  " E'\\n'\n"
646  " ) AS \"%s\",\n"
647  " pg_catalog.pg_get_userbyid(t.typowner) AS \"%s\",\n",
648  gettext_noop("Internal name"),
649  gettext_noop("Size"),
650  gettext_noop("Elements"),
651  gettext_noop("Owner"));
652  printACLColumn(&buf, "t.typacl");
653  appendPQExpBufferStr(&buf, ",\n ");
654  }
655 
657  " pg_catalog.obj_description(t.oid, 'pg_type') as \"%s\"\n",
658  gettext_noop("Description"));
659 
660  appendPQExpBufferStr(&buf, "FROM pg_catalog.pg_type t\n"
661  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n");
662 
663  /*
664  * do not include complex types (typrelid!=0) unless they are standalone
665  * composite types
666  */
667  appendPQExpBufferStr(&buf, "WHERE (t.typrelid = 0 ");
668  appendPQExpBufferStr(&buf, "OR (SELECT c.relkind = " CppAsString2(RELKIND_COMPOSITE_TYPE)
669  " FROM pg_catalog.pg_class c "
670  "WHERE c.oid = t.typrelid))\n");
671 
672  /*
673  * do not include array types unless the pattern contains []
674  */
675  if (pattern == NULL || strstr(pattern, "[]") == NULL)
676  appendPQExpBufferStr(&buf, " AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)\n");
677 
678  if (!showSystem && !pattern)
679  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
680  " AND n.nspname <> 'information_schema'\n");
681 
682  /* Match name pattern against either internal or external name */
684  true, false,
685  "n.nspname", "t.typname",
686  "pg_catalog.format_type(t.oid, NULL)",
687  "pg_catalog.pg_type_is_visible(t.oid)",
688  NULL, 3))
689  {
691  return false;
692  }
693 
694  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
695 
696  res = PSQLexec(buf.data);
698  if (!res)
699  return false;
700 
701  myopt.title = _("List of data types");
702  myopt.translate_header = true;
703 
704  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
705 
706  PQclear(res);
707  return true;
708 }
709 
710 /*
711  * Map some variant type names accepted by the backend grammar into
712  * canonical type names.
713  *
714  * Helper for \dT and other functions that take typename patterns.
715  * This doesn't completely mask the fact that these names are special;
716  * for example, a pattern of "dec*" won't magically match "numeric".
717  * But it goes a long way to reduce the surprise factor.
718  */
719 static const char *
720 map_typename_pattern(const char *pattern)
721 {
722  static const char *const typename_map[] = {
723  /*
724  * These names are accepted by gram.y, although they are neither the
725  * "real" name seen in pg_type nor the canonical name printed by
726  * format_type().
727  */
728  "decimal", "numeric",
729  "float", "double precision",
730  "int", "integer",
731 
732  /*
733  * We also have to map the array names for cases where the canonical
734  * name is different from what pg_type says.
735  */
736  "bool[]", "boolean[]",
737  "decimal[]", "numeric[]",
738  "float[]", "double precision[]",
739  "float4[]", "real[]",
740  "float8[]", "double precision[]",
741  "int[]", "integer[]",
742  "int2[]", "smallint[]",
743  "int4[]", "integer[]",
744  "int8[]", "bigint[]",
745  "time[]", "time without time zone[]",
746  "timetz[]", "time with time zone[]",
747  "timestamp[]", "timestamp without time zone[]",
748  "timestamptz[]", "timestamp with time zone[]",
749  "varbit[]", "bit varying[]",
750  "varchar[]", "character varying[]",
751  NULL
752  };
753 
754  if (pattern == NULL)
755  return NULL;
756  for (int i = 0; typename_map[i] != NULL; i += 2)
757  {
758  if (pg_strcasecmp(pattern, typename_map[i]) == 0)
759  return typename_map[i + 1];
760  }
761  return pattern;
762 }
763 
764 
765 /*
766  * \do
767  * Describe operators
768  */
769 bool
770 describeOperators(const char *oper_pattern,
771  char **arg_patterns, int num_arg_patterns,
772  bool verbose, bool showSystem)
773 {
775  PGresult *res;
776  printQueryOpt myopt = pset.popt;
777 
779 
780  /*
781  * Note: before Postgres 9.1, we did not assign comments to any built-in
782  * operators, preferring to let the comment on the underlying function
783  * suffice. The coalesce() on the obj_description() calls below supports
784  * this convention by providing a fallback lookup of a comment on the
785  * operator's function. Since 9.1 there is a policy that every built-in
786  * operator should have a comment; so the coalesce() is no longer
787  * necessary so far as built-in operators are concerned. We keep it
788  * anyway, for now, because third-party modules may still be following the
789  * old convention.
790  *
791  * The support for postfix operators in this query is dead code as of
792  * Postgres 14, but we need to keep it for as long as we support talking
793  * to pre-v14 servers.
794  */
795 
797  "SELECT n.nspname as \"%s\",\n"
798  " o.oprname AS \"%s\",\n"
799  " CASE WHEN o.oprkind='l' THEN NULL ELSE pg_catalog.format_type(o.oprleft, NULL) END AS \"%s\",\n"
800  " CASE WHEN o.oprkind='r' THEN NULL ELSE pg_catalog.format_type(o.oprright, NULL) END AS \"%s\",\n"
801  " pg_catalog.format_type(o.oprresult, NULL) AS \"%s\",\n",
802  gettext_noop("Schema"),
803  gettext_noop("Name"),
804  gettext_noop("Left arg type"),
805  gettext_noop("Right arg type"),
806  gettext_noop("Result type"));
807 
808  if (verbose)
810  " o.oprcode AS \"%s\",\n",
811  gettext_noop("Function"));
812 
814  " coalesce(pg_catalog.obj_description(o.oid, 'pg_operator'),\n"
815  " pg_catalog.obj_description(o.oprcode, 'pg_proc')) AS \"%s\"\n"
816  "FROM pg_catalog.pg_operator o\n"
817  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace\n",
818  gettext_noop("Description"));
819 
820  if (num_arg_patterns >= 2)
821  {
822  num_arg_patterns = 2; /* ignore any additional arguments */
824  " LEFT JOIN pg_catalog.pg_type t0 ON t0.oid = o.oprleft\n"
825  " LEFT JOIN pg_catalog.pg_namespace nt0 ON nt0.oid = t0.typnamespace\n"
826  " LEFT JOIN pg_catalog.pg_type t1 ON t1.oid = o.oprright\n"
827  " LEFT JOIN pg_catalog.pg_namespace nt1 ON nt1.oid = t1.typnamespace\n");
828  }
829  else if (num_arg_patterns == 1)
830  {
832  " LEFT JOIN pg_catalog.pg_type t0 ON t0.oid = o.oprright\n"
833  " LEFT JOIN pg_catalog.pg_namespace nt0 ON nt0.oid = t0.typnamespace\n");
834  }
835 
836  if (!showSystem && !oper_pattern)
837  appendPQExpBufferStr(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
838  " AND n.nspname <> 'information_schema'\n");
839 
840  if (!validateSQLNamePattern(&buf, oper_pattern,
841  !showSystem && !oper_pattern, true,
842  "n.nspname", "o.oprname", NULL,
843  "pg_catalog.pg_operator_is_visible(o.oid)",
844  NULL, 3))
845  goto error_return;
846 
847  if (num_arg_patterns == 1)
848  appendPQExpBufferStr(&buf, " AND o.oprleft = 0\n");
849 
850  for (int i = 0; i < num_arg_patterns; i++)
851  {
852  if (strcmp(arg_patterns[i], "-") != 0)
853  {
854  /*
855  * Match type-name patterns against either internal or external
856  * name, like \dT. Unlike \dT, there seems no reason to
857  * discriminate against arrays or composite types.
858  */
859  char nspname[64];
860  char typname[64];
861  char ft[64];
862  char tiv[64];
863 
864  snprintf(nspname, sizeof(nspname), "nt%d.nspname", i);
865  snprintf(typname, sizeof(typname), "t%d.typname", i);
866  snprintf(ft, sizeof(ft),
867  "pg_catalog.format_type(t%d.oid, NULL)", i);
868  snprintf(tiv, sizeof(tiv),
869  "pg_catalog.pg_type_is_visible(t%d.oid)", i);
871  map_typename_pattern(arg_patterns[i]),
872  true, false,
873  nspname, typname, ft, tiv,
874  NULL, 3))
875  goto error_return;
876  }
877  else
878  {
879  /* "-" pattern specifies no such parameter */
880  appendPQExpBuffer(&buf, " AND t%d.typname IS NULL\n", i);
881  }
882  }
883 
884  appendPQExpBufferStr(&buf, "ORDER BY 1, 2, 3, 4;");
885 
886  res = PSQLexec(buf.data);
888  if (!res)
889  return false;
890 
891  myopt.title = _("List of operators");
892  myopt.translate_header = true;
893 
894  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
895 
896  PQclear(res);
897  return true;
898 
899 error_return:
901  return false;
902 }
903 
904 
905 /*
906  * listAllDbs
907  *
908  * for \l, \list, and -l switch
909  */
910 bool
911 listAllDbs(const char *pattern, bool verbose)
912 {
913  PGresult *res;
915  printQueryOpt myopt = pset.popt;
916 
918 
920  "SELECT\n"
921  " d.datname as \"%s\",\n"
922  " pg_catalog.pg_get_userbyid(d.datdba) as \"%s\",\n"
923  " pg_catalog.pg_encoding_to_char(d.encoding) as \"%s\",\n",
924  gettext_noop("Name"),
925  gettext_noop("Owner"),
926  gettext_noop("Encoding"));
927  if (pset.sversion >= 150000)
929  " CASE d.datlocprovider WHEN 'b' THEN 'builtin' WHEN 'c' THEN 'libc' WHEN 'i' THEN 'icu' END AS \"%s\",\n",
930  gettext_noop("Locale Provider"));
931  else
933  " 'libc' AS \"%s\",\n",
934  gettext_noop("Locale Provider"));
936  " d.datcollate as \"%s\",\n"
937  " d.datctype as \"%s\",\n",
938  gettext_noop("Collate"),
939  gettext_noop("Ctype"));
940  if (pset.sversion >= 170000)
942  " d.datlocale as \"%s\",\n",
943  gettext_noop("Locale"));
944  else if (pset.sversion >= 150000)
946  " d.daticulocale as \"%s\",\n",
947  gettext_noop("Locale"));
948  else
950  " NULL as \"%s\",\n",
951  gettext_noop("Locale"));
952  if (pset.sversion >= 160000)
954  " d.daticurules as \"%s\",\n",
955  gettext_noop("ICU Rules"));
956  else
958  " NULL as \"%s\",\n",
959  gettext_noop("ICU Rules"));
960  appendPQExpBufferStr(&buf, " ");
961  printACLColumn(&buf, "d.datacl");
962  if (verbose)
964  ",\n CASE WHEN pg_catalog.has_database_privilege(d.datname, 'CONNECT')\n"
965  " THEN pg_catalog.pg_size_pretty(pg_catalog.pg_database_size(d.datname))\n"
966  " ELSE 'No Access'\n"
967  " END as \"%s\""
968  ",\n t.spcname as \"%s\""
969  ",\n pg_catalog.shobj_description(d.oid, 'pg_database') as \"%s\"",
970  gettext_noop("Size"),
971  gettext_noop("Tablespace"),
972  gettext_noop("Description"));
974  "\nFROM pg_catalog.pg_database d\n");
975  if (verbose)
977  " JOIN pg_catalog.pg_tablespace t on d.dattablespace = t.oid\n");
978 
979  if (pattern)
980  {
981  if (!validateSQLNamePattern(&buf, pattern, false, false,
982  NULL, "d.datname", NULL, NULL,
983  NULL, 1))
984  {
986  return false;
987  }
988  }
989 
990  appendPQExpBufferStr(&buf, "ORDER BY 1;");
991  res = PSQLexec(buf.data);
993  if (!res)
994  return false;
995 
996  myopt.title = _("List of databases");
997  myopt.translate_header = true;
998 
999  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
1000 
1001  PQclear(res);
1002  return true;
1003 }
1004 
1005 
1006 /*
1007  * List Tables' Grant/Revoke Permissions
1008  * \z (now also \dp -- perhaps more mnemonic)
1009  */
1010 bool
1011 permissionsList(const char *pattern, bool showSystem)
1012 {
1014  PGresult *res;
1015  printQueryOpt myopt = pset.popt;
1016  static const bool translate_columns[] = {false, false, true, false, false, false};
1017 
1018  initPQExpBuffer(&buf);
1019 
1020  /*
1021  * we ignore indexes and toast tables since they have no meaningful rights
1022  */
1024  "SELECT n.nspname as \"%s\",\n"
1025  " c.relname as \"%s\",\n"
1026  " CASE c.relkind"
1027  " WHEN " CppAsString2(RELKIND_RELATION) " THEN '%s'"
1028  " WHEN " CppAsString2(RELKIND_VIEW) " THEN '%s'"
1029  " WHEN " CppAsString2(RELKIND_MATVIEW) " THEN '%s'"
1030  " WHEN " CppAsString2(RELKIND_SEQUENCE) " THEN '%s'"
1031  " WHEN " CppAsString2(RELKIND_FOREIGN_TABLE) " THEN '%s'"
1032  " WHEN " CppAsString2(RELKIND_PARTITIONED_TABLE) " THEN '%s'"
1033  " END as \"%s\",\n"
1034  " ",
1035  gettext_noop("Schema"),
1036  gettext_noop("Name"),
1037  gettext_noop("table"),
1038  gettext_noop("view"),
1039  gettext_noop("materialized view"),
1040  gettext_noop("sequence"),
1041  gettext_noop("foreign table"),
1042  gettext_noop("partitioned table"),
1043  gettext_noop("Type"));
1044 
1045  printACLColumn(&buf, "c.relacl");
1046 
1047  /*
1048  * The formatting of attacl should match printACLColumn(). However, we
1049  * need no special case for an empty attacl, because the backend always
1050  * optimizes that back to NULL.
1051  */
1053  ",\n pg_catalog.array_to_string(ARRAY(\n"
1054  " SELECT attname || E':\\n ' || pg_catalog.array_to_string(attacl, E'\\n ')\n"
1055  " FROM pg_catalog.pg_attribute a\n"
1056  " WHERE attrelid = c.oid AND NOT attisdropped AND attacl IS NOT NULL\n"
1057  " ), E'\\n') AS \"%s\"",
1058  gettext_noop("Column privileges"));
1059 
1060  if (pset.sversion >= 90500 && pset.sversion < 100000)
1062  ",\n pg_catalog.array_to_string(ARRAY(\n"
1063  " SELECT polname\n"
1064  " || CASE WHEN polcmd != '*' THEN\n"
1065  " E' (' || polcmd::pg_catalog.text || E'):'\n"
1066  " ELSE E':'\n"
1067  " END\n"
1068  " || CASE WHEN polqual IS NOT NULL THEN\n"
1069  " E'\\n (u): ' || pg_catalog.pg_get_expr(polqual, polrelid)\n"
1070  " ELSE E''\n"
1071  " END\n"
1072  " || CASE WHEN polwithcheck IS NOT NULL THEN\n"
1073  " E'\\n (c): ' || pg_catalog.pg_get_expr(polwithcheck, polrelid)\n"
1074  " ELSE E''\n"
1075  " END"
1076  " || CASE WHEN polroles <> '{0}' THEN\n"
1077  " E'\\n to: ' || pg_catalog.array_to_string(\n"
1078  " ARRAY(\n"
1079  " SELECT rolname\n"
1080  " FROM pg_catalog.pg_roles\n"
1081  " WHERE oid = ANY (polroles)\n"
1082  " ORDER BY 1\n"
1083  " ), E', ')\n"
1084  " ELSE E''\n"
1085  " END\n"
1086  " FROM pg_catalog.pg_policy pol\n"
1087  " WHERE polrelid = c.oid), E'\\n')\n"
1088  " AS \"%s\"",
1089  gettext_noop("Policies"));
1090 
1091  if (pset.sversion >= 100000)
1093  ",\n pg_catalog.array_to_string(ARRAY(\n"
1094  " SELECT polname\n"
1095  " || CASE WHEN NOT polpermissive THEN\n"
1096  " E' (RESTRICTIVE)'\n"
1097  " ELSE '' END\n"
1098  " || CASE WHEN polcmd != '*' THEN\n"
1099  " E' (' || polcmd::pg_catalog.text || E'):'\n"
1100  " ELSE E':'\n"
1101  " END\n"
1102  " || CASE WHEN polqual IS NOT NULL THEN\n"
1103  " E'\\n (u): ' || pg_catalog.pg_get_expr(polqual, polrelid)\n"
1104  " ELSE E''\n"
1105  " END\n"
1106  " || CASE WHEN polwithcheck IS NOT NULL THEN\n"
1107  " E'\\n (c): ' || pg_catalog.pg_get_expr(polwithcheck, polrelid)\n"
1108  " ELSE E''\n"
1109  " END"
1110  " || CASE WHEN polroles <> '{0}' THEN\n"
1111  " E'\\n to: ' || pg_catalog.array_to_string(\n"
1112  " ARRAY(\n"
1113  " SELECT rolname\n"
1114  " FROM pg_catalog.pg_roles\n"
1115  " WHERE oid = ANY (polroles)\n"
1116  " ORDER BY 1\n"
1117  " ), E', ')\n"
1118  " ELSE E''\n"
1119  " END\n"
1120  " FROM pg_catalog.pg_policy pol\n"
1121  " WHERE polrelid = c.oid), E'\\n')\n"
1122  " AS \"%s\"",
1123  gettext_noop("Policies"));
1124 
1125  appendPQExpBufferStr(&buf, "\nFROM pg_catalog.pg_class c\n"
1126  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n"
1127  "WHERE c.relkind IN ("
1128  CppAsString2(RELKIND_RELATION) ","
1129  CppAsString2(RELKIND_VIEW) ","
1130  CppAsString2(RELKIND_MATVIEW) ","
1131  CppAsString2(RELKIND_SEQUENCE) ","
1132  CppAsString2(RELKIND_FOREIGN_TABLE) ","
1133  CppAsString2(RELKIND_PARTITIONED_TABLE) ")\n");
1134 
1135  if (!showSystem && !pattern)
1136  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
1137  " AND n.nspname <> 'information_schema'\n");
1138 
1139  if (!validateSQLNamePattern(&buf, pattern, true, false,
1140  "n.nspname", "c.relname", NULL,
1141  "pg_catalog.pg_table_is_visible(c.oid)",
1142  NULL, 3))
1143  goto error_return;
1144 
1145  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
1146 
1147  res = PSQLexec(buf.data);
1148  if (!res)
1149  goto error_return;
1150 
1151  printfPQExpBuffer(&buf, _("Access privileges"));
1152  myopt.title = buf.data;
1153  myopt.translate_header = true;
1154  myopt.translate_columns = translate_columns;
1155  myopt.n_translate_columns = lengthof(translate_columns);
1156 
1157  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
1158 
1159  termPQExpBuffer(&buf);
1160  PQclear(res);
1161  return true;
1162 
1163 error_return:
1164  termPQExpBuffer(&buf);
1165  return false;
1166 }
1167 
1168 
1169 /*
1170  * \ddp
1171  *
1172  * List Default ACLs. The pattern can match either schema or role name.
1173  */
1174 bool
1175 listDefaultACLs(const char *pattern)
1176 {
1178  PGresult *res;
1179  printQueryOpt myopt = pset.popt;
1180  static const bool translate_columns[] = {false, false, true, false};
1181 
1182  initPQExpBuffer(&buf);
1183 
1185  "SELECT pg_catalog.pg_get_userbyid(d.defaclrole) AS \"%s\",\n"
1186  " n.nspname AS \"%s\",\n"
1187  " CASE d.defaclobjtype WHEN '%c' THEN '%s' WHEN '%c' THEN '%s' WHEN '%c' THEN '%s' WHEN '%c' THEN '%s' WHEN '%c' THEN '%s' END AS \"%s\",\n"
1188  " ",
1189  gettext_noop("Owner"),
1190  gettext_noop("Schema"),
1191  DEFACLOBJ_RELATION,
1192  gettext_noop("table"),
1193  DEFACLOBJ_SEQUENCE,
1194  gettext_noop("sequence"),
1195  DEFACLOBJ_FUNCTION,
1196  gettext_noop("function"),
1197  DEFACLOBJ_TYPE,
1198  gettext_noop("type"),
1199  DEFACLOBJ_NAMESPACE,
1200  gettext_noop("schema"),
1201  gettext_noop("Type"));
1202 
1203  printACLColumn(&buf, "d.defaclacl");
1204 
1205  appendPQExpBufferStr(&buf, "\nFROM pg_catalog.pg_default_acl d\n"
1206  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = d.defaclnamespace\n");
1207 
1208  if (!validateSQLNamePattern(&buf, pattern, false, false,
1209  NULL,
1210  "n.nspname",
1211  "pg_catalog.pg_get_userbyid(d.defaclrole)",
1212  NULL,
1213  NULL, 3))
1214  goto error_return;
1215 
1216  appendPQExpBufferStr(&buf, "ORDER BY 1, 2, 3;");
1217 
1218  res = PSQLexec(buf.data);
1219  if (!res)
1220  goto error_return;
1221 
1222  printfPQExpBuffer(&buf, _("Default access privileges"));
1223  myopt.title = buf.data;
1224  myopt.translate_header = true;
1225  myopt.translate_columns = translate_columns;
1226  myopt.n_translate_columns = lengthof(translate_columns);
1227 
1228  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
1229 
1230  termPQExpBuffer(&buf);
1231  PQclear(res);
1232  return true;
1233 
1234 error_return:
1235  termPQExpBuffer(&buf);
1236  return false;
1237 }
1238 
1239 
1240 /*
1241  * Get object comments
1242  *
1243  * \dd [foo]
1244  *
1245  * Note: This command only lists comments for object types which do not have
1246  * their comments displayed by their own backslash commands. The following
1247  * types of objects will be displayed: constraint, operator class,
1248  * operator family, rule, and trigger.
1249  *
1250  */
1251 bool
1252 objectDescription(const char *pattern, bool showSystem)
1253 {
1255  PGresult *res;
1256  printQueryOpt myopt = pset.popt;
1257  static const bool translate_columns[] = {false, false, true, false};
1258 
1259  initPQExpBuffer(&buf);
1260 
1262  "SELECT DISTINCT tt.nspname AS \"%s\", tt.name AS \"%s\", tt.object AS \"%s\", d.description AS \"%s\"\n"
1263  "FROM (\n",
1264  gettext_noop("Schema"),
1265  gettext_noop("Name"),
1266  gettext_noop("Object"),
1267  gettext_noop("Description"));
1268 
1269  /* Table constraint descriptions */
1271  " SELECT pgc.oid as oid, pgc.tableoid AS tableoid,\n"
1272  " n.nspname as nspname,\n"
1273  " CAST(pgc.conname AS pg_catalog.text) as name,"
1274  " CAST('%s' AS pg_catalog.text) as object\n"
1275  " FROM pg_catalog.pg_constraint pgc\n"
1276  " JOIN pg_catalog.pg_class c "
1277  "ON c.oid = pgc.conrelid\n"
1278  " LEFT JOIN pg_catalog.pg_namespace n "
1279  " ON n.oid = c.relnamespace\n",
1280  gettext_noop("table constraint"));
1281 
1282  if (!showSystem && !pattern)
1283  appendPQExpBufferStr(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
1284  " AND n.nspname <> 'information_schema'\n");
1285 
1286  if (!validateSQLNamePattern(&buf, pattern, !showSystem && !pattern,
1287  false, "n.nspname", "pgc.conname", NULL,
1288  "pg_catalog.pg_table_is_visible(c.oid)",
1289  NULL, 3))
1290  goto error_return;
1291 
1292  /* Domain constraint descriptions */
1294  "UNION ALL\n"
1295  " SELECT pgc.oid as oid, pgc.tableoid AS tableoid,\n"
1296  " n.nspname as nspname,\n"
1297  " CAST(pgc.conname AS pg_catalog.text) as name,"
1298  " CAST('%s' AS pg_catalog.text) as object\n"
1299  " FROM pg_catalog.pg_constraint pgc\n"
1300  " JOIN pg_catalog.pg_type t "
1301  "ON t.oid = pgc.contypid\n"
1302  " LEFT JOIN pg_catalog.pg_namespace n "
1303  " ON n.oid = t.typnamespace\n",
1304  gettext_noop("domain constraint"));
1305 
1306  if (!showSystem && !pattern)
1307  appendPQExpBufferStr(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
1308  " AND n.nspname <> 'information_schema'\n");
1309 
1310  if (!validateSQLNamePattern(&buf, pattern, !showSystem && !pattern,
1311  false, "n.nspname", "pgc.conname", NULL,
1312  "pg_catalog.pg_type_is_visible(t.oid)",
1313  NULL, 3))
1314  goto error_return;
1315 
1316  /* Operator class descriptions */
1318  "UNION ALL\n"
1319  " SELECT o.oid as oid, o.tableoid as tableoid,\n"
1320  " n.nspname as nspname,\n"
1321  " CAST(o.opcname AS pg_catalog.text) as name,\n"
1322  " CAST('%s' AS pg_catalog.text) as object\n"
1323  " FROM pg_catalog.pg_opclass o\n"
1324  " JOIN pg_catalog.pg_am am ON "
1325  "o.opcmethod = am.oid\n"
1326  " JOIN pg_catalog.pg_namespace n ON "
1327  "n.oid = o.opcnamespace\n",
1328  gettext_noop("operator class"));
1329 
1330  if (!showSystem && !pattern)
1331  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
1332  " AND n.nspname <> 'information_schema'\n");
1333 
1334  if (!validateSQLNamePattern(&buf, pattern, true, false,
1335  "n.nspname", "o.opcname", NULL,
1336  "pg_catalog.pg_opclass_is_visible(o.oid)",
1337  NULL, 3))
1338  goto error_return;
1339 
1340  /* Operator family descriptions */
1342  "UNION ALL\n"
1343  " SELECT opf.oid as oid, opf.tableoid as tableoid,\n"
1344  " n.nspname as nspname,\n"
1345  " CAST(opf.opfname AS pg_catalog.text) AS name,\n"
1346  " CAST('%s' AS pg_catalog.text) as object\n"
1347  " FROM pg_catalog.pg_opfamily opf\n"
1348  " JOIN pg_catalog.pg_am am "
1349  "ON opf.opfmethod = am.oid\n"
1350  " JOIN pg_catalog.pg_namespace n "
1351  "ON opf.opfnamespace = n.oid\n",
1352  gettext_noop("operator family"));
1353 
1354  if (!showSystem && !pattern)
1355  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
1356  " AND n.nspname <> 'information_schema'\n");
1357 
1358  if (!validateSQLNamePattern(&buf, pattern, true, false,
1359  "n.nspname", "opf.opfname", NULL,
1360  "pg_catalog.pg_opfamily_is_visible(opf.oid)",
1361  NULL, 3))
1362  goto error_return;
1363 
1364  /* Rule descriptions (ignore rules for views) */
1366  "UNION ALL\n"
1367  " SELECT r.oid as oid, r.tableoid as tableoid,\n"
1368  " n.nspname as nspname,\n"
1369  " CAST(r.rulename AS pg_catalog.text) as name,"
1370  " CAST('%s' AS pg_catalog.text) as object\n"
1371  " FROM pg_catalog.pg_rewrite r\n"
1372  " JOIN pg_catalog.pg_class c ON c.oid = r.ev_class\n"
1373  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n"
1374  " WHERE r.rulename != '_RETURN'\n",
1375  gettext_noop("rule"));
1376 
1377  if (!showSystem && !pattern)
1378  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
1379  " AND n.nspname <> 'information_schema'\n");
1380 
1381  if (!validateSQLNamePattern(&buf, pattern, true, false,
1382  "n.nspname", "r.rulename", NULL,
1383  "pg_catalog.pg_table_is_visible(c.oid)",
1384  NULL, 3))
1385  goto error_return;
1386 
1387  /* Trigger descriptions */
1389  "UNION ALL\n"
1390  " SELECT t.oid as oid, t.tableoid as tableoid,\n"
1391  " n.nspname as nspname,\n"
1392  " CAST(t.tgname AS pg_catalog.text) as name,"
1393  " CAST('%s' AS pg_catalog.text) as object\n"
1394  " FROM pg_catalog.pg_trigger t\n"
1395  " JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid\n"
1396  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n",
1397  gettext_noop("trigger"));
1398 
1399  if (!showSystem && !pattern)
1400  appendPQExpBufferStr(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
1401  " AND n.nspname <> 'information_schema'\n");
1402 
1403  if (!validateSQLNamePattern(&buf, pattern, !showSystem && !pattern, false,
1404  "n.nspname", "t.tgname", NULL,
1405  "pg_catalog.pg_table_is_visible(c.oid)",
1406  NULL, 3))
1407  goto error_return;
1408 
1410  ") AS tt\n"
1411  " JOIN pg_catalog.pg_description d ON (tt.oid = d.objoid AND tt.tableoid = d.classoid AND d.objsubid = 0)\n");
1412 
1413  appendPQExpBufferStr(&buf, "ORDER BY 1, 2, 3;");
1414 
1415  res = PSQLexec(buf.data);
1416  termPQExpBuffer(&buf);
1417  if (!res)
1418  return false;
1419 
1420  myopt.title = _("Object descriptions");
1421  myopt.translate_header = true;
1422  myopt.translate_columns = translate_columns;
1423  myopt.n_translate_columns = lengthof(translate_columns);
1424 
1425  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
1426 
1427  PQclear(res);
1428  return true;
1429 
1430 error_return:
1431  termPQExpBuffer(&buf);
1432  return false;
1433 }
1434 
1435 
1436 /*
1437  * describeTableDetails (for \d)
1438  *
1439  * This routine finds the tables to be displayed, and calls
1440  * describeOneTableDetails for each one.
1441  *
1442  * verbose: if true, this is \d+
1443  */
1444 bool
1445 describeTableDetails(const char *pattern, bool verbose, bool showSystem)
1446 {
1448  PGresult *res;
1449  int i;
1450 
1451  initPQExpBuffer(&buf);
1452 
1454  "SELECT c.oid,\n"
1455  " n.nspname,\n"
1456  " c.relname\n"
1457  "FROM pg_catalog.pg_class c\n"
1458  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n");
1459 
1460  if (!showSystem && !pattern)
1461  appendPQExpBufferStr(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
1462  " AND n.nspname <> 'information_schema'\n");
1463 
1464  if (!validateSQLNamePattern(&buf, pattern, !showSystem && !pattern, false,
1465  "n.nspname", "c.relname", NULL,
1466  "pg_catalog.pg_table_is_visible(c.oid)",
1467  NULL, 3))
1468  {
1469  termPQExpBuffer(&buf);
1470  return false;
1471  }
1472 
1473  appendPQExpBufferStr(&buf, "ORDER BY 2, 3;");
1474 
1475  res = PSQLexec(buf.data);
1476  termPQExpBuffer(&buf);
1477  if (!res)
1478  return false;
1479 
1480  if (PQntuples(res) == 0)
1481  {
1482  if (!pset.quiet)
1483  {
1484  if (pattern)
1485  pg_log_error("Did not find any relation named \"%s\".",
1486  pattern);
1487  else
1488  pg_log_error("Did not find any relations.");
1489  }
1490  PQclear(res);
1491  return false;
1492  }
1493 
1494  for (i = 0; i < PQntuples(res); i++)
1495  {
1496  const char *oid;
1497  const char *nspname;
1498  const char *relname;
1499 
1500  oid = PQgetvalue(res, i, 0);
1501  nspname = PQgetvalue(res, i, 1);
1502  relname = PQgetvalue(res, i, 2);
1503 
1504  if (!describeOneTableDetails(nspname, relname, oid, verbose))
1505  {
1506  PQclear(res);
1507  return false;
1508  }
1509  if (cancel_pressed)
1510  {
1511  PQclear(res);
1512  return false;
1513  }
1514  }
1515 
1516  PQclear(res);
1517  return true;
1518 }
1519 
1520 /*
1521  * describeOneTableDetails (for \d)
1522  *
1523  * Unfortunately, the information presented here is so complicated that it
1524  * cannot be done in a single query. So we have to assemble the printed table
1525  * by hand and pass it to the underlying printTable() function.
1526  */
1527 static bool
1528 describeOneTableDetails(const char *schemaname,
1529  const char *relationname,
1530  const char *oid,
1531  bool verbose)
1532 {
1533  bool retval = false;
1535  PGresult *res = NULL;
1536  printTableOpt myopt = pset.popt.topt;
1537  printTableContent cont;
1538  bool printTableInitialized = false;
1539  int i;
1540  char *view_def = NULL;
1541  char *headers[12];
1542  PQExpBufferData title;
1544  int cols;
1545  int attname_col = -1, /* column indexes in "res" */
1546  atttype_col = -1,
1547  attrdef_col = -1,
1548  attnotnull_col = -1,
1549  attcoll_col = -1,
1550  attidentity_col = -1,
1551  attgenerated_col = -1,
1552  isindexkey_col = -1,
1553  indexdef_col = -1,
1554  fdwopts_col = -1,
1555  attstorage_col = -1,
1556  attcompression_col = -1,
1557  attstattarget_col = -1,
1558  attdescr_col = -1;
1559  int numrows;
1560  struct
1561  {
1562  int16 checks;
1563  char relkind;
1564  bool hasindex;
1565  bool hasrules;
1566  bool hastriggers;
1567  bool rowsecurity;
1568  bool forcerowsecurity;
1569  bool hasoids;
1570  bool ispartition;
1571  Oid tablespace;
1572  char *reloptions;
1573  char *reloftype;
1574  char relpersistence;
1575  char relreplident;
1576  char *relam;
1577  } tableinfo;
1578  bool show_column_details = false;
1579 
1580  myopt.default_footer = false;
1581  /* This output looks confusing in expanded mode. */
1582  myopt.expanded = false;
1583 
1584  initPQExpBuffer(&buf);
1585  initPQExpBuffer(&title);
1587 
1588  /* Get general table info */
1589  if (pset.sversion >= 120000)
1590  {
1592  "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
1593  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
1594  "false AS relhasoids, c.relispartition, %s, c.reltablespace, "
1595  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
1596  "c.relpersistence, c.relreplident, am.amname\n"
1597  "FROM pg_catalog.pg_class c\n "
1598  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
1599  "LEFT JOIN pg_catalog.pg_am am ON (c.relam = am.oid)\n"
1600  "WHERE c.oid = '%s';",
1601  (verbose ?
1602  "pg_catalog.array_to_string(c.reloptions || "
1603  "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
1604  : "''"),
1605  oid);
1606  }
1607  else if (pset.sversion >= 100000)
1608  {
1610  "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
1611  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
1612  "c.relhasoids, c.relispartition, %s, c.reltablespace, "
1613  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
1614  "c.relpersistence, c.relreplident\n"
1615  "FROM pg_catalog.pg_class c\n "
1616  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
1617  "WHERE c.oid = '%s';",
1618  (verbose ?
1619  "pg_catalog.array_to_string(c.reloptions || "
1620  "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
1621  : "''"),
1622  oid);
1623  }
1624  else if (pset.sversion >= 90500)
1625  {
1627  "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
1628  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
1629  "c.relhasoids, false as relispartition, %s, c.reltablespace, "
1630  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
1631  "c.relpersistence, c.relreplident\n"
1632  "FROM pg_catalog.pg_class c\n "
1633  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
1634  "WHERE c.oid = '%s';",
1635  (verbose ?
1636  "pg_catalog.array_to_string(c.reloptions || "
1637  "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
1638  : "''"),
1639  oid);
1640  }
1641  else if (pset.sversion >= 90400)
1642  {
1644  "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
1645  "c.relhastriggers, false, false, c.relhasoids, "
1646  "false as relispartition, %s, c.reltablespace, "
1647  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
1648  "c.relpersistence, c.relreplident\n"
1649  "FROM pg_catalog.pg_class c\n "
1650  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
1651  "WHERE c.oid = '%s';",
1652  (verbose ?
1653  "pg_catalog.array_to_string(c.reloptions || "
1654  "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
1655  : "''"),
1656  oid);
1657  }
1658  else
1659  {
1661  "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
1662  "c.relhastriggers, false, false, c.relhasoids, "
1663  "false as relispartition, %s, c.reltablespace, "
1664  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
1665  "c.relpersistence\n"
1666  "FROM pg_catalog.pg_class c\n "
1667  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
1668  "WHERE c.oid = '%s';",
1669  (verbose ?
1670  "pg_catalog.array_to_string(c.reloptions || "
1671  "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
1672  : "''"),
1673  oid);
1674  }
1675 
1676  res = PSQLexec(buf.data);
1677  if (!res)
1678  goto error_return;
1679 
1680  /* Did we get anything? */
1681  if (PQntuples(res) == 0)
1682  {
1683  if (!pset.quiet)
1684  pg_log_error("Did not find any relation with OID %s.", oid);
1685  goto error_return;
1686  }
1687 
1688  tableinfo.checks = atoi(PQgetvalue(res, 0, 0));
1689  tableinfo.relkind = *(PQgetvalue(res, 0, 1));
1690  tableinfo.hasindex = strcmp(PQgetvalue(res, 0, 2), "t") == 0;
1691  tableinfo.hasrules = strcmp(PQgetvalue(res, 0, 3), "t") == 0;
1692  tableinfo.hastriggers = strcmp(PQgetvalue(res, 0, 4), "t") == 0;
1693  tableinfo.rowsecurity = strcmp(PQgetvalue(res, 0, 5), "t") == 0;
1694  tableinfo.forcerowsecurity = strcmp(PQgetvalue(res, 0, 6), "t") == 0;
1695  tableinfo.hasoids = strcmp(PQgetvalue(res, 0, 7), "t") == 0;
1696  tableinfo.ispartition = strcmp(PQgetvalue(res, 0, 8), "t") == 0;
1697  tableinfo.reloptions = pg_strdup(PQgetvalue(res, 0, 9));
1698  tableinfo.tablespace = atooid(PQgetvalue(res, 0, 10));
1699  tableinfo.reloftype = (strcmp(PQgetvalue(res, 0, 11), "") != 0) ?
1700  pg_strdup(PQgetvalue(res, 0, 11)) : NULL;
1701  tableinfo.relpersistence = *(PQgetvalue(res, 0, 12));
1702  tableinfo.relreplident = (pset.sversion >= 90400) ?
1703  *(PQgetvalue(res, 0, 13)) : 'd';
1704  if (pset.sversion >= 120000)
1705  tableinfo.relam = PQgetisnull(res, 0, 14) ?
1706  (char *) NULL : pg_strdup(PQgetvalue(res, 0, 14));
1707  else
1708  tableinfo.relam = NULL;
1709  PQclear(res);
1710  res = NULL;
1711 
1712  /*
1713  * If it's a sequence, deal with it here separately.
1714  */
1715  if (tableinfo.relkind == RELKIND_SEQUENCE)
1716  {
1717  PGresult *result = NULL;
1718  printQueryOpt myopt = pset.popt;
1719  char *footers[2] = {NULL, NULL};
1720 
1721  if (pset.sversion >= 100000)
1722  {
1724  "SELECT pg_catalog.format_type(seqtypid, NULL) AS \"%s\",\n"
1725  " seqstart AS \"%s\",\n"
1726  " seqmin AS \"%s\",\n"
1727  " seqmax AS \"%s\",\n"
1728  " seqincrement AS \"%s\",\n"
1729  " CASE WHEN seqcycle THEN '%s' ELSE '%s' END AS \"%s\",\n"
1730  " seqcache AS \"%s\"\n",
1731  gettext_noop("Type"),
1732  gettext_noop("Start"),
1733  gettext_noop("Minimum"),
1734  gettext_noop("Maximum"),
1735  gettext_noop("Increment"),
1736  gettext_noop("yes"),
1737  gettext_noop("no"),
1738  gettext_noop("Cycles?"),
1739  gettext_noop("Cache"));
1741  "FROM pg_catalog.pg_sequence\n"
1742  "WHERE seqrelid = '%s';",
1743  oid);
1744  }
1745  else
1746  {
1748  "SELECT 'bigint' AS \"%s\",\n"
1749  " start_value AS \"%s\",\n"
1750  " min_value AS \"%s\",\n"
1751  " max_value AS \"%s\",\n"
1752  " increment_by AS \"%s\",\n"
1753  " CASE WHEN is_cycled THEN '%s' ELSE '%s' END AS \"%s\",\n"
1754  " cache_value AS \"%s\"\n",
1755  gettext_noop("Type"),
1756  gettext_noop("Start"),
1757  gettext_noop("Minimum"),
1758  gettext_noop("Maximum"),
1759  gettext_noop("Increment"),
1760  gettext_noop("yes"),
1761  gettext_noop("no"),
1762  gettext_noop("Cycles?"),
1763  gettext_noop("Cache"));
1764  appendPQExpBuffer(&buf, "FROM %s", fmtId(schemaname));
1765  /* must be separate because fmtId isn't reentrant */
1766  appendPQExpBuffer(&buf, ".%s;", fmtId(relationname));
1767  }
1768 
1769  res = PSQLexec(buf.data);
1770  if (!res)
1771  goto error_return;
1772 
1773  /* Get the column that owns this sequence */
1774  printfPQExpBuffer(&buf, "SELECT pg_catalog.quote_ident(nspname) || '.' ||"
1775  "\n pg_catalog.quote_ident(relname) || '.' ||"
1776  "\n pg_catalog.quote_ident(attname),"
1777  "\n d.deptype"
1778  "\nFROM pg_catalog.pg_class c"
1779  "\nINNER JOIN pg_catalog.pg_depend d ON c.oid=d.refobjid"
1780  "\nINNER JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace"
1781  "\nINNER JOIN pg_catalog.pg_attribute a ON ("
1782  "\n a.attrelid=c.oid AND"
1783  "\n a.attnum=d.refobjsubid)"
1784  "\nWHERE d.classid='pg_catalog.pg_class'::pg_catalog.regclass"
1785  "\n AND d.refclassid='pg_catalog.pg_class'::pg_catalog.regclass"
1786  "\n AND d.objid='%s'"
1787  "\n AND d.deptype IN ('a', 'i')",
1788  oid);
1789 
1790  result = PSQLexec(buf.data);
1791 
1792  /*
1793  * If we get no rows back, don't show anything (obviously). We should
1794  * never get more than one row back, but if we do, just ignore it and
1795  * don't print anything.
1796  */
1797  if (!result)
1798  goto error_return;
1799  else if (PQntuples(result) == 1)
1800  {
1801  switch (PQgetvalue(result, 0, 1)[0])
1802  {
1803  case 'a':
1804  footers[0] = psprintf(_("Owned by: %s"),
1805  PQgetvalue(result, 0, 0));
1806  break;
1807  case 'i':
1808  footers[0] = psprintf(_("Sequence for identity column: %s"),
1809  PQgetvalue(result, 0, 0));
1810  break;
1811  }
1812  }
1813  PQclear(result);
1814 
1815  if (tableinfo.relpersistence == 'u')
1816  printfPQExpBuffer(&title, _("Unlogged sequence \"%s.%s\""),
1817  schemaname, relationname);
1818  else
1819  printfPQExpBuffer(&title, _("Sequence \"%s.%s\""),
1820  schemaname, relationname);
1821 
1822  myopt.footers = footers;
1823  myopt.topt.default_footer = false;
1824  myopt.title = title.data;
1825  myopt.translate_header = true;
1826 
1827  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
1828 
1829  free(footers[0]);
1830 
1831  retval = true;
1832  goto error_return; /* not an error, just return early */
1833  }
1834 
1835  /* Identify whether we should print collation, nullable, default vals */
1836  if (tableinfo.relkind == RELKIND_RELATION ||
1837  tableinfo.relkind == RELKIND_VIEW ||
1838  tableinfo.relkind == RELKIND_MATVIEW ||
1839  tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
1840  tableinfo.relkind == RELKIND_COMPOSITE_TYPE ||
1841  tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
1842  show_column_details = true;
1843 
1844  /*
1845  * Get per-column info
1846  *
1847  * Since the set of query columns we need varies depending on relkind and
1848  * server version, we compute all the column numbers on-the-fly. Column
1849  * number variables for columns not fetched are left as -1; this avoids
1850  * duplicative test logic below.
1851  */
1852  cols = 0;
1853  printfPQExpBuffer(&buf, "SELECT a.attname");
1854  attname_col = cols++;
1855  appendPQExpBufferStr(&buf, ",\n pg_catalog.format_type(a.atttypid, a.atttypmod)");
1856  atttype_col = cols++;
1857 
1858  if (show_column_details)
1859  {
1860  /* use "pretty" mode for expression to avoid excessive parentheses */
1862  ",\n (SELECT pg_catalog.pg_get_expr(d.adbin, d.adrelid, true)"
1863  "\n FROM pg_catalog.pg_attrdef d"
1864  "\n WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef)"
1865  ",\n a.attnotnull");
1866  attrdef_col = cols++;
1867  attnotnull_col = cols++;
1868  appendPQExpBufferStr(&buf, ",\n (SELECT c.collname FROM pg_catalog.pg_collation c, pg_catalog.pg_type t\n"
1869  " WHERE c.oid = a.attcollation AND t.oid = a.atttypid AND a.attcollation <> t.typcollation) AS attcollation");
1870  attcoll_col = cols++;
1871  if (pset.sversion >= 100000)
1872  appendPQExpBufferStr(&buf, ",\n a.attidentity");
1873  else
1874  appendPQExpBufferStr(&buf, ",\n ''::pg_catalog.char AS attidentity");
1875  attidentity_col = cols++;
1876  if (pset.sversion >= 120000)
1877  appendPQExpBufferStr(&buf, ",\n a.attgenerated");
1878  else
1879  appendPQExpBufferStr(&buf, ",\n ''::pg_catalog.char AS attgenerated");
1880  attgenerated_col = cols++;
1881  }
1882  if (tableinfo.relkind == RELKIND_INDEX ||
1883  tableinfo.relkind == RELKIND_PARTITIONED_INDEX)
1884  {
1885  if (pset.sversion >= 110000)
1886  {
1887  appendPQExpBuffer(&buf, ",\n CASE WHEN a.attnum <= (SELECT i.indnkeyatts FROM pg_catalog.pg_index i WHERE i.indexrelid = '%s') THEN '%s' ELSE '%s' END AS is_key",
1888  oid,
1889  gettext_noop("yes"),
1890  gettext_noop("no"));
1891  isindexkey_col = cols++;
1892  }
1893  appendPQExpBufferStr(&buf, ",\n pg_catalog.pg_get_indexdef(a.attrelid, a.attnum, TRUE) AS indexdef");
1894  indexdef_col = cols++;
1895  }
1896  /* FDW options for foreign table column */
1897  if (tableinfo.relkind == RELKIND_FOREIGN_TABLE)
1898  {
1899  appendPQExpBufferStr(&buf, ",\n CASE WHEN attfdwoptions IS NULL THEN '' ELSE "
1900  " '(' || pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value) FROM "
1901  " pg_catalog.pg_options_to_table(attfdwoptions)), ', ') || ')' END AS attfdwoptions");
1902  fdwopts_col = cols++;
1903  }
1904  if (verbose)
1905  {
1906  appendPQExpBufferStr(&buf, ",\n a.attstorage");
1907  attstorage_col = cols++;
1908 
1909  /* compression info, if relevant to relkind */
1910  if (pset.sversion >= 140000 &&
1912  (tableinfo.relkind == RELKIND_RELATION ||
1913  tableinfo.relkind == RELKIND_PARTITIONED_TABLE ||
1914  tableinfo.relkind == RELKIND_MATVIEW))
1915  {
1916  appendPQExpBufferStr(&buf, ",\n a.attcompression AS attcompression");
1917  attcompression_col = cols++;
1918  }
1919 
1920  /* stats target, if relevant to relkind */
1921  if (tableinfo.relkind == RELKIND_RELATION ||
1922  tableinfo.relkind == RELKIND_INDEX ||
1923  tableinfo.relkind == RELKIND_PARTITIONED_INDEX ||
1924  tableinfo.relkind == RELKIND_MATVIEW ||
1925  tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
1926  tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
1927  {
1928  appendPQExpBufferStr(&buf, ",\n CASE WHEN a.attstattarget=-1 THEN NULL ELSE a.attstattarget END AS attstattarget");
1929  attstattarget_col = cols++;
1930  }
1931 
1932  /*
1933  * In 9.0+, we have column comments for: relations, views, composite
1934  * types, and foreign tables (cf. CommentObject() in comment.c).
1935  */
1936  if (tableinfo.relkind == RELKIND_RELATION ||
1937  tableinfo.relkind == RELKIND_VIEW ||
1938  tableinfo.relkind == RELKIND_MATVIEW ||
1939  tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
1940  tableinfo.relkind == RELKIND_COMPOSITE_TYPE ||
1941  tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
1942  {
1943  appendPQExpBufferStr(&buf, ",\n pg_catalog.col_description(a.attrelid, a.attnum)");
1944  attdescr_col = cols++;
1945  }
1946  }
1947 
1948  appendPQExpBufferStr(&buf, "\nFROM pg_catalog.pg_attribute a");
1949  appendPQExpBuffer(&buf, "\nWHERE a.attrelid = '%s' AND a.attnum > 0 AND NOT a.attisdropped", oid);
1950  appendPQExpBufferStr(&buf, "\nORDER BY a.attnum;");
1951 
1952  res = PSQLexec(buf.data);
1953  if (!res)
1954  goto error_return;
1955  numrows = PQntuples(res);
1956 
1957  /* Make title */
1958  switch (tableinfo.relkind)
1959  {
1960  case RELKIND_RELATION:
1961  if (tableinfo.relpersistence == 'u')
1962  printfPQExpBuffer(&title, _("Unlogged table \"%s.%s\""),
1963  schemaname, relationname);
1964  else
1965  printfPQExpBuffer(&title, _("Table \"%s.%s\""),
1966  schemaname, relationname);
1967  break;
1968  case RELKIND_VIEW:
1969  printfPQExpBuffer(&title, _("View \"%s.%s\""),
1970  schemaname, relationname);
1971  break;
1972  case RELKIND_MATVIEW:
1973  if (tableinfo.relpersistence == 'u')
1974  printfPQExpBuffer(&title, _("Unlogged materialized view \"%s.%s\""),
1975  schemaname, relationname);
1976  else
1977  printfPQExpBuffer(&title, _("Materialized view \"%s.%s\""),
1978  schemaname, relationname);
1979  break;
1980  case RELKIND_INDEX:
1981  if (tableinfo.relpersistence == 'u')
1982  printfPQExpBuffer(&title, _("Unlogged index \"%s.%s\""),
1983  schemaname, relationname);
1984  else
1985  printfPQExpBuffer(&title, _("Index \"%s.%s\""),
1986  schemaname, relationname);
1987  break;
1988  case RELKIND_PARTITIONED_INDEX:
1989  if (tableinfo.relpersistence == 'u')
1990  printfPQExpBuffer(&title, _("Unlogged partitioned index \"%s.%s\""),
1991  schemaname, relationname);
1992  else
1993  printfPQExpBuffer(&title, _("Partitioned index \"%s.%s\""),
1994  schemaname, relationname);
1995  break;
1996  case RELKIND_TOASTVALUE:
1997  printfPQExpBuffer(&title, _("TOAST table \"%s.%s\""),
1998  schemaname, relationname);
1999  break;
2000  case RELKIND_COMPOSITE_TYPE:
2001  printfPQExpBuffer(&title, _("Composite type \"%s.%s\""),
2002  schemaname, relationname);
2003  break;
2004  case RELKIND_FOREIGN_TABLE:
2005  printfPQExpBuffer(&title, _("Foreign table \"%s.%s\""),
2006  schemaname, relationname);
2007  break;
2008  case RELKIND_PARTITIONED_TABLE:
2009  if (tableinfo.relpersistence == 'u')
2010  printfPQExpBuffer(&title, _("Unlogged partitioned table \"%s.%s\""),
2011  schemaname, relationname);
2012  else
2013  printfPQExpBuffer(&title, _("Partitioned table \"%s.%s\""),
2014  schemaname, relationname);
2015  break;
2016  default:
2017  /* untranslated unknown relkind */
2018  printfPQExpBuffer(&title, "?%c? \"%s.%s\"",
2019  tableinfo.relkind, schemaname, relationname);
2020  break;
2021  }
2022 
2023  /* Fill headers[] with the names of the columns we will output */
2024  cols = 0;
2025  headers[cols++] = gettext_noop("Column");
2026  headers[cols++] = gettext_noop("Type");
2027  if (show_column_details)
2028  {
2029  headers[cols++] = gettext_noop("Collation");
2030  headers[cols++] = gettext_noop("Nullable");
2031  headers[cols++] = gettext_noop("Default");
2032  }
2033  if (isindexkey_col >= 0)
2034  headers[cols++] = gettext_noop("Key?");
2035  if (indexdef_col >= 0)
2036  headers[cols++] = gettext_noop("Definition");
2037  if (fdwopts_col >= 0)
2038  headers[cols++] = gettext_noop("FDW options");
2039  if (attstorage_col >= 0)
2040  headers[cols++] = gettext_noop("Storage");
2041  if (attcompression_col >= 0)
2042  headers[cols++] = gettext_noop("Compression");
2043  if (attstattarget_col >= 0)
2044  headers[cols++] = gettext_noop("Stats target");
2045  if (attdescr_col >= 0)
2046  headers[cols++] = gettext_noop("Description");
2047 
2048  Assert(cols <= lengthof(headers));
2049 
2050  printTableInit(&cont, &myopt, title.data, cols, numrows);
2051  printTableInitialized = true;
2052 
2053  for (i = 0; i < cols; i++)
2054  printTableAddHeader(&cont, headers[i], true, 'l');
2055 
2056  /* Generate table cells to be printed */
2057  for (i = 0; i < numrows; i++)
2058  {
2059  /* Column */
2060  printTableAddCell(&cont, PQgetvalue(res, i, attname_col), false, false);
2061 
2062  /* Type */
2063  printTableAddCell(&cont, PQgetvalue(res, i, atttype_col), false, false);
2064 
2065  /* Collation, Nullable, Default */
2066  if (show_column_details)
2067  {
2068  char *identity;
2069  char *generated;
2070  char *default_str;
2071  bool mustfree = false;
2072 
2073  printTableAddCell(&cont, PQgetvalue(res, i, attcoll_col), false, false);
2074 
2075  printTableAddCell(&cont,
2076  strcmp(PQgetvalue(res, i, attnotnull_col), "t") == 0 ? "not null" : "",
2077  false, false);
2078 
2079  identity = PQgetvalue(res, i, attidentity_col);
2080  generated = PQgetvalue(res, i, attgenerated_col);
2081 
2082  if (identity[0] == ATTRIBUTE_IDENTITY_ALWAYS)
2083  default_str = "generated always as identity";
2084  else if (identity[0] == ATTRIBUTE_IDENTITY_BY_DEFAULT)
2085  default_str = "generated by default as identity";
2086  else if (generated[0] == ATTRIBUTE_GENERATED_STORED)
2087  {
2088  default_str = psprintf("generated always as (%s) stored",
2089  PQgetvalue(res, i, attrdef_col));
2090  mustfree = true;
2091  }
2092  else
2093  default_str = PQgetvalue(res, i, attrdef_col);
2094 
2095  printTableAddCell(&cont, default_str, false, mustfree);
2096  }
2097 
2098  /* Info for index columns */
2099  if (isindexkey_col >= 0)
2100  printTableAddCell(&cont, PQgetvalue(res, i, isindexkey_col), true, false);
2101  if (indexdef_col >= 0)
2102  printTableAddCell(&cont, PQgetvalue(res, i, indexdef_col), false, false);
2103 
2104  /* FDW options for foreign table columns */
2105  if (fdwopts_col >= 0)
2106  printTableAddCell(&cont, PQgetvalue(res, i, fdwopts_col), false, false);
2107 
2108  /* Storage mode, if relevant */
2109  if (attstorage_col >= 0)
2110  {
2111  char *storage = PQgetvalue(res, i, attstorage_col);
2112 
2113  /* these strings are literal in our syntax, so not translated. */
2114  printTableAddCell(&cont, (storage[0] == 'p' ? "plain" :
2115  (storage[0] == 'm' ? "main" :
2116  (storage[0] == 'x' ? "extended" :
2117  (storage[0] == 'e' ? "external" :
2118  "???")))),
2119  false, false);
2120  }
2121 
2122  /* Column compression, if relevant */
2123  if (attcompression_col >= 0)
2124  {
2125  char *compression = PQgetvalue(res, i, attcompression_col);
2126 
2127  /* these strings are literal in our syntax, so not translated. */
2128  printTableAddCell(&cont, (compression[0] == 'p' ? "pglz" :
2129  (compression[0] == 'l' ? "lz4" :
2130  (compression[0] == '\0' ? "" :
2131  "???"))),
2132  false, false);
2133  }
2134 
2135  /* Statistics target, if the relkind supports this feature */
2136  if (attstattarget_col >= 0)
2137  printTableAddCell(&cont, PQgetvalue(res, i, attstattarget_col),
2138  false, false);
2139 
2140  /* Column comments, if the relkind supports this feature */
2141  if (attdescr_col >= 0)
2142  printTableAddCell(&cont, PQgetvalue(res, i, attdescr_col),
2143  false, false);
2144  }
2145 
2146  /* Make footers */
2147 
2148  if (tableinfo.ispartition)
2149  {
2150  /* Footer information for a partition child table */
2151  PGresult *result;
2152 
2154  "SELECT inhparent::pg_catalog.regclass,\n"
2155  " pg_catalog.pg_get_expr(c.relpartbound, c.oid),\n ");
2156 
2158  pset.sversion >= 140000 ? "inhdetachpending" :
2159  "false as inhdetachpending");
2160 
2161  /* If verbose, also request the partition constraint definition */
2162  if (verbose)
2164  ",\n pg_catalog.pg_get_partition_constraintdef(c.oid)");
2166  "\nFROM pg_catalog.pg_class c"
2167  " JOIN pg_catalog.pg_inherits i"
2168  " ON c.oid = inhrelid"
2169  "\nWHERE c.oid = '%s';", oid);
2170  result = PSQLexec(buf.data);
2171  if (!result)
2172  goto error_return;
2173 
2174  if (PQntuples(result) > 0)
2175  {
2176  char *parent_name = PQgetvalue(result, 0, 0);
2177  char *partdef = PQgetvalue(result, 0, 1);
2178  char *detached = PQgetvalue(result, 0, 2);
2179 
2180  printfPQExpBuffer(&tmpbuf, _("Partition of: %s %s%s"), parent_name,
2181  partdef,
2182  strcmp(detached, "t") == 0 ? " DETACH PENDING" : "");
2184 
2185  if (verbose)
2186  {
2187  char *partconstraintdef = NULL;
2188 
2189  if (!PQgetisnull(result, 0, 3))
2190  partconstraintdef = PQgetvalue(result, 0, 3);
2191  /* If there isn't any constraint, show that explicitly */
2192  if (partconstraintdef == NULL || partconstraintdef[0] == '\0')
2193  printfPQExpBuffer(&tmpbuf, _("No partition constraint"));
2194  else
2195  printfPQExpBuffer(&tmpbuf, _("Partition constraint: %s"),
2196  partconstraintdef);
2198  }
2199  }
2200  PQclear(result);
2201  }
2202 
2203  if (tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
2204  {
2205  /* Footer information for a partitioned table (partitioning parent) */
2206  PGresult *result;
2207 
2209  "SELECT pg_catalog.pg_get_partkeydef('%s'::pg_catalog.oid);",
2210  oid);
2211  result = PSQLexec(buf.data);
2212  if (!result)
2213  goto error_return;
2214 
2215  if (PQntuples(result) == 1)
2216  {
2217  char *partkeydef = PQgetvalue(result, 0, 0);
2218 
2219  printfPQExpBuffer(&tmpbuf, _("Partition key: %s"), partkeydef);
2221  }
2222  PQclear(result);
2223  }
2224 
2225  if (tableinfo.relkind == RELKIND_TOASTVALUE)
2226  {
2227  /* For a TOAST table, print name of owning table */
2228  PGresult *result;
2229 
2231  "SELECT n.nspname, c.relname\n"
2232  "FROM pg_catalog.pg_class c"
2233  " JOIN pg_catalog.pg_namespace n"
2234  " ON n.oid = c.relnamespace\n"
2235  "WHERE reltoastrelid = '%s';", oid);
2236  result = PSQLexec(buf.data);
2237  if (!result)
2238  goto error_return;
2239 
2240  if (PQntuples(result) == 1)
2241  {
2242  char *schemaname = PQgetvalue(result, 0, 0);
2243  char *relname = PQgetvalue(result, 0, 1);
2244 
2245  printfPQExpBuffer(&tmpbuf, _("Owning table: \"%s.%s\""),
2246  schemaname, relname);
2248  }
2249  PQclear(result);
2250  }
2251 
2252  if (tableinfo.relkind == RELKIND_INDEX ||
2253  tableinfo.relkind == RELKIND_PARTITIONED_INDEX)
2254  {
2255  /* Footer information about an index */
2256  PGresult *result;
2257 
2259  "SELECT i.indisunique, i.indisprimary, i.indisclustered, "
2260  "i.indisvalid,\n"
2261  " (NOT i.indimmediate) AND "
2262  "EXISTS (SELECT 1 FROM pg_catalog.pg_constraint "
2263  "WHERE conrelid = i.indrelid AND "
2264  "conindid = i.indexrelid AND "
2265  "contype IN ('p','u','x') AND "
2266  "condeferrable) AS condeferrable,\n"
2267  " (NOT i.indimmediate) AND "
2268  "EXISTS (SELECT 1 FROM pg_catalog.pg_constraint "
2269  "WHERE conrelid = i.indrelid AND "
2270  "conindid = i.indexrelid AND "
2271  "contype IN ('p','u','x') AND "
2272  "condeferred) AS condeferred,\n");
2273 
2274  if (pset.sversion >= 90400)
2275  appendPQExpBufferStr(&buf, "i.indisreplident,\n");
2276  else
2277  appendPQExpBufferStr(&buf, "false AS indisreplident,\n");
2278 
2279  if (pset.sversion >= 150000)
2280  appendPQExpBufferStr(&buf, "i.indnullsnotdistinct,\n");
2281  else
2282  appendPQExpBufferStr(&buf, "false AS indnullsnotdistinct,\n");
2283 
2284  appendPQExpBuffer(&buf, " a.amname, c2.relname, "
2285  "pg_catalog.pg_get_expr(i.indpred, i.indrelid, true)\n"
2286  "FROM pg_catalog.pg_index i, pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_am a\n"
2287  "WHERE i.indexrelid = c.oid AND c.oid = '%s' AND c.relam = a.oid\n"
2288  "AND i.indrelid = c2.oid;",
2289  oid);
2290 
2291  result = PSQLexec(buf.data);
2292  if (!result)
2293  goto error_return;
2294  else if (PQntuples(result) != 1)
2295  {
2296  PQclear(result);
2297  goto error_return;
2298  }
2299  else
2300  {
2301  char *indisunique = PQgetvalue(result, 0, 0);
2302  char *indisprimary = PQgetvalue(result, 0, 1);
2303  char *indisclustered = PQgetvalue(result, 0, 2);
2304  char *indisvalid = PQgetvalue(result, 0, 3);
2305  char *deferrable = PQgetvalue(result, 0, 4);
2306  char *deferred = PQgetvalue(result, 0, 5);
2307  char *indisreplident = PQgetvalue(result, 0, 6);
2308  char *indnullsnotdistinct = PQgetvalue(result, 0, 7);
2309  char *indamname = PQgetvalue(result, 0, 8);
2310  char *indtable = PQgetvalue(result, 0, 9);
2311  char *indpred = PQgetvalue(result, 0, 10);
2312 
2313  if (strcmp(indisprimary, "t") == 0)
2314  printfPQExpBuffer(&tmpbuf, _("primary key, "));
2315  else if (strcmp(indisunique, "t") == 0)
2316  {
2317  printfPQExpBuffer(&tmpbuf, _("unique"));
2318  if (strcmp(indnullsnotdistinct, "t") == 0)
2319  appendPQExpBufferStr(&tmpbuf, _(" nulls not distinct"));
2320  appendPQExpBufferStr(&tmpbuf, _(", "));
2321  }
2322  else
2324  appendPQExpBuffer(&tmpbuf, "%s, ", indamname);
2325 
2326  /* we assume here that index and table are in same schema */
2327  appendPQExpBuffer(&tmpbuf, _("for table \"%s.%s\""),
2328  schemaname, indtable);
2329 
2330  if (strlen(indpred))
2331  appendPQExpBuffer(&tmpbuf, _(", predicate (%s)"), indpred);
2332 
2333  if (strcmp(indisclustered, "t") == 0)
2334  appendPQExpBufferStr(&tmpbuf, _(", clustered"));
2335 
2336  if (strcmp(indisvalid, "t") != 0)
2337  appendPQExpBufferStr(&tmpbuf, _(", invalid"));
2338 
2339  if (strcmp(deferrable, "t") == 0)
2340  appendPQExpBufferStr(&tmpbuf, _(", deferrable"));
2341 
2342  if (strcmp(deferred, "t") == 0)
2343  appendPQExpBufferStr(&tmpbuf, _(", initially deferred"));
2344 
2345  if (strcmp(indisreplident, "t") == 0)
2346  appendPQExpBufferStr(&tmpbuf, _(", replica identity"));
2347 
2349 
2350  /*
2351  * If it's a partitioned index, we'll print the tablespace below
2352  */
2353  if (tableinfo.relkind == RELKIND_INDEX)
2354  add_tablespace_footer(&cont, tableinfo.relkind,
2355  tableinfo.tablespace, true);
2356  }
2357 
2358  PQclear(result);
2359  }
2360  /* If you add relkinds here, see also "Finish printing..." stanza below */
2361  else if (tableinfo.relkind == RELKIND_RELATION ||
2362  tableinfo.relkind == RELKIND_MATVIEW ||
2363  tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
2364  tableinfo.relkind == RELKIND_PARTITIONED_TABLE ||
2365  tableinfo.relkind == RELKIND_PARTITIONED_INDEX ||
2366  tableinfo.relkind == RELKIND_TOASTVALUE)
2367  {
2368  /* Footer information about a table */
2369  PGresult *result = NULL;
2370  int tuples = 0;
2371 
2372  /* print indexes */
2373  if (tableinfo.hasindex)
2374  {
2376  "SELECT c2.relname, i.indisprimary, i.indisunique, "
2377  "i.indisclustered, i.indisvalid, "
2378  "pg_catalog.pg_get_indexdef(i.indexrelid, 0, true),\n "
2379  "pg_catalog.pg_get_constraintdef(con.oid, true), "
2380  "contype, condeferrable, condeferred");
2381  if (pset.sversion >= 90400)
2382  appendPQExpBufferStr(&buf, ", i.indisreplident");
2383  else
2384  appendPQExpBufferStr(&buf, ", false AS indisreplident");
2385  appendPQExpBufferStr(&buf, ", c2.reltablespace");
2387  "\nFROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i\n"
2388  " LEFT JOIN pg_catalog.pg_constraint con ON (conrelid = i.indrelid AND conindid = i.indexrelid AND contype IN ('p','u','x'))\n"
2389  "WHERE c.oid = '%s' AND c.oid = i.indrelid AND i.indexrelid = c2.oid\n"
2390  "ORDER BY i.indisprimary DESC, c2.relname;",
2391  oid);
2392  result = PSQLexec(buf.data);
2393  if (!result)
2394  goto error_return;
2395  else
2396  tuples = PQntuples(result);
2397 
2398  if (tuples > 0)
2399  {
2400  printTableAddFooter(&cont, _("Indexes:"));
2401  for (i = 0; i < tuples; i++)
2402  {
2403  /* untranslated index name */
2404  printfPQExpBuffer(&buf, " \"%s\"",
2405  PQgetvalue(result, i, 0));
2406 
2407  /* If exclusion constraint, print the constraintdef */
2408  if (strcmp(PQgetvalue(result, i, 7), "x") == 0)
2409  {
2410  appendPQExpBuffer(&buf, " %s",
2411  PQgetvalue(result, i, 6));
2412  }
2413  else
2414  {
2415  const char *indexdef;
2416  const char *usingpos;
2417 
2418  /* Label as primary key or unique (but not both) */
2419  if (strcmp(PQgetvalue(result, i, 1), "t") == 0)
2420  appendPQExpBufferStr(&buf, " PRIMARY KEY,");
2421  else if (strcmp(PQgetvalue(result, i, 2), "t") == 0)
2422  {
2423  if (strcmp(PQgetvalue(result, i, 7), "u") == 0)
2424  appendPQExpBufferStr(&buf, " UNIQUE CONSTRAINT,");
2425  else
2426  appendPQExpBufferStr(&buf, " UNIQUE,");
2427  }
2428 
2429  /* Everything after "USING" is echoed verbatim */
2430  indexdef = PQgetvalue(result, i, 5);
2431  usingpos = strstr(indexdef, " USING ");
2432  if (usingpos)
2433  indexdef = usingpos + 7;
2434  appendPQExpBuffer(&buf, " %s", indexdef);
2435 
2436  /* Need these for deferrable PK/UNIQUE indexes */
2437  if (strcmp(PQgetvalue(result, i, 8), "t") == 0)
2438  appendPQExpBufferStr(&buf, " DEFERRABLE");
2439 
2440  if (strcmp(PQgetvalue(result, i, 9), "t") == 0)
2441  appendPQExpBufferStr(&buf, " INITIALLY DEFERRED");
2442  }
2443 
2444  /* Add these for all cases */
2445  if (strcmp(PQgetvalue(result, i, 3), "t") == 0)
2446  appendPQExpBufferStr(&buf, " CLUSTER");
2447 
2448  if (strcmp(PQgetvalue(result, i, 4), "t") != 0)
2449  appendPQExpBufferStr(&buf, " INVALID");
2450 
2451  if (strcmp(PQgetvalue(result, i, 10), "t") == 0)
2452  appendPQExpBufferStr(&buf, " REPLICA IDENTITY");
2453 
2454  printTableAddFooter(&cont, buf.data);
2455 
2456  /* Print tablespace of the index on the same line */
2457  add_tablespace_footer(&cont, RELKIND_INDEX,
2458  atooid(PQgetvalue(result, i, 11)),
2459  false);
2460  }
2461  }
2462  PQclear(result);
2463  }
2464 
2465  /* print table (and column) check constraints */
2466  if (tableinfo.checks)
2467  {
2469  "SELECT r.conname, "
2470  "pg_catalog.pg_get_constraintdef(r.oid, true)\n"
2471  "FROM pg_catalog.pg_constraint r\n"
2472  "WHERE r.conrelid = '%s' AND r.contype = 'c'\n"
2473  "ORDER BY 1;",
2474  oid);
2475  result = PSQLexec(buf.data);
2476  if (!result)
2477  goto error_return;
2478  else
2479  tuples = PQntuples(result);
2480 
2481  if (tuples > 0)
2482  {
2483  printTableAddFooter(&cont, _("Check constraints:"));
2484  for (i = 0; i < tuples; i++)
2485  {
2486  /* untranslated constraint name and def */
2487  printfPQExpBuffer(&buf, " \"%s\" %s",
2488  PQgetvalue(result, i, 0),
2489  PQgetvalue(result, i, 1));
2490 
2491  printTableAddFooter(&cont, buf.data);
2492  }
2493  }
2494  PQclear(result);
2495  }
2496 
2497  /*
2498  * Print foreign-key constraints (there are none if no triggers,
2499  * except if the table is partitioned, in which case the triggers
2500  * appear in the partitions)
2501  */
2502  if (tableinfo.hastriggers ||
2503  tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
2504  {
2505  if (pset.sversion >= 120000 &&
2506  (tableinfo.ispartition || tableinfo.relkind == RELKIND_PARTITIONED_TABLE))
2507  {
2508  /*
2509  * Put the constraints defined in this table first, followed
2510  * by the constraints defined in ancestor partitioned tables.
2511  */
2513  "SELECT conrelid = '%s'::pg_catalog.regclass AS sametable,\n"
2514  " conname,\n"
2515  " pg_catalog.pg_get_constraintdef(oid, true) AS condef,\n"
2516  " conrelid::pg_catalog.regclass AS ontable\n"
2517  " FROM pg_catalog.pg_constraint,\n"
2518  " pg_catalog.pg_partition_ancestors('%s')\n"
2519  " WHERE conrelid = relid AND contype = 'f' AND conparentid = 0\n"
2520  "ORDER BY sametable DESC, conname;",
2521  oid, oid);
2522  }
2523  else
2524  {
2526  "SELECT true as sametable, conname,\n"
2527  " pg_catalog.pg_get_constraintdef(r.oid, true) as condef,\n"
2528  " conrelid::pg_catalog.regclass AS ontable\n"
2529  "FROM pg_catalog.pg_constraint r\n"
2530  "WHERE r.conrelid = '%s' AND r.contype = 'f'\n",
2531  oid);
2532 
2533  if (pset.sversion >= 120000)
2534  appendPQExpBufferStr(&buf, " AND conparentid = 0\n");
2535  appendPQExpBufferStr(&buf, "ORDER BY conname");
2536  }
2537 
2538  result = PSQLexec(buf.data);
2539  if (!result)
2540  goto error_return;
2541  else
2542  tuples = PQntuples(result);
2543 
2544  if (tuples > 0)
2545  {
2546  int i_sametable = PQfnumber(result, "sametable"),
2547  i_conname = PQfnumber(result, "conname"),
2548  i_condef = PQfnumber(result, "condef"),
2549  i_ontable = PQfnumber(result, "ontable");
2550 
2551  printTableAddFooter(&cont, _("Foreign-key constraints:"));
2552  for (i = 0; i < tuples; i++)
2553  {
2554  /*
2555  * Print untranslated constraint name and definition. Use
2556  * a "TABLE tab" prefix when the constraint is defined in
2557  * a parent partitioned table.
2558  */
2559  if (strcmp(PQgetvalue(result, i, i_sametable), "f") == 0)
2560  printfPQExpBuffer(&buf, " TABLE \"%s\" CONSTRAINT \"%s\" %s",
2561  PQgetvalue(result, i, i_ontable),
2562  PQgetvalue(result, i, i_conname),
2563  PQgetvalue(result, i, i_condef));
2564  else
2565  printfPQExpBuffer(&buf, " \"%s\" %s",
2566  PQgetvalue(result, i, i_conname),
2567  PQgetvalue(result, i, i_condef));
2568 
2569  printTableAddFooter(&cont, buf.data);
2570  }
2571  }
2572  PQclear(result);
2573  }
2574 
2575  /* print incoming foreign-key references */
2576  if (tableinfo.hastriggers ||
2577  tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
2578  {
2579  if (pset.sversion >= 120000)
2580  {
2582  "SELECT conname, conrelid::pg_catalog.regclass AS ontable,\n"
2583  " pg_catalog.pg_get_constraintdef(oid, true) AS condef\n"
2584  " FROM pg_catalog.pg_constraint c\n"
2585  " WHERE confrelid IN (SELECT pg_catalog.pg_partition_ancestors('%s')\n"
2586  " UNION ALL VALUES ('%s'::pg_catalog.regclass))\n"
2587  " AND contype = 'f' AND conparentid = 0\n"
2588  "ORDER BY conname;",
2589  oid, oid);
2590  }
2591  else
2592  {
2594  "SELECT conname, conrelid::pg_catalog.regclass AS ontable,\n"
2595  " pg_catalog.pg_get_constraintdef(oid, true) AS condef\n"
2596  " FROM pg_catalog.pg_constraint\n"
2597  " WHERE confrelid = %s AND contype = 'f'\n"
2598  "ORDER BY conname;",
2599  oid);
2600  }
2601 
2602  result = PSQLexec(buf.data);
2603  if (!result)
2604  goto error_return;
2605  else
2606  tuples = PQntuples(result);
2607 
2608  if (tuples > 0)
2609  {
2610  int i_conname = PQfnumber(result, "conname"),
2611  i_ontable = PQfnumber(result, "ontable"),
2612  i_condef = PQfnumber(result, "condef");
2613 
2614  printTableAddFooter(&cont, _("Referenced by:"));
2615  for (i = 0; i < tuples; i++)
2616  {
2617  printfPQExpBuffer(&buf, " TABLE \"%s\" CONSTRAINT \"%s\" %s",
2618  PQgetvalue(result, i, i_ontable),
2619  PQgetvalue(result, i, i_conname),
2620  PQgetvalue(result, i, i_condef));
2621 
2622  printTableAddFooter(&cont, buf.data);
2623  }
2624  }
2625  PQclear(result);
2626  }
2627 
2628  /* print any row-level policies */
2629  if (pset.sversion >= 90500)
2630  {
2631  printfPQExpBuffer(&buf, "SELECT pol.polname,");
2632  if (pset.sversion >= 100000)
2634  " pol.polpermissive,\n");
2635  else
2637  " 't' as polpermissive,\n");
2639  " CASE WHEN pol.polroles = '{0}' THEN NULL ELSE pg_catalog.array_to_string(array(select rolname from pg_catalog.pg_roles where oid = any (pol.polroles) order by 1),',') END,\n"
2640  " pg_catalog.pg_get_expr(pol.polqual, pol.polrelid),\n"
2641  " pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid),\n"
2642  " CASE pol.polcmd\n"
2643  " WHEN 'r' THEN 'SELECT'\n"
2644  " WHEN 'a' THEN 'INSERT'\n"
2645  " WHEN 'w' THEN 'UPDATE'\n"
2646  " WHEN 'd' THEN 'DELETE'\n"
2647  " END AS cmd\n"
2648  "FROM pg_catalog.pg_policy pol\n"
2649  "WHERE pol.polrelid = '%s' ORDER BY 1;",
2650  oid);
2651 
2652  result = PSQLexec(buf.data);
2653  if (!result)
2654  goto error_return;
2655  else
2656  tuples = PQntuples(result);
2657 
2658  /*
2659  * Handle cases where RLS is enabled and there are policies, or
2660  * there aren't policies, or RLS isn't enabled but there are
2661  * policies
2662  */
2663  if (tableinfo.rowsecurity && !tableinfo.forcerowsecurity && tuples > 0)
2664  printTableAddFooter(&cont, _("Policies:"));
2665 
2666  if (tableinfo.rowsecurity && tableinfo.forcerowsecurity && tuples > 0)
2667  printTableAddFooter(&cont, _("Policies (forced row security enabled):"));
2668 
2669  if (tableinfo.rowsecurity && !tableinfo.forcerowsecurity && tuples == 0)
2670  printTableAddFooter(&cont, _("Policies (row security enabled): (none)"));
2671 
2672  if (tableinfo.rowsecurity && tableinfo.forcerowsecurity && tuples == 0)
2673  printTableAddFooter(&cont, _("Policies (forced row security enabled): (none)"));
2674 
2675  if (!tableinfo.rowsecurity && tuples > 0)
2676  printTableAddFooter(&cont, _("Policies (row security disabled):"));
2677 
2678  /* Might be an empty set - that's ok */
2679  for (i = 0; i < tuples; i++)
2680  {
2681  printfPQExpBuffer(&buf, " POLICY \"%s\"",
2682  PQgetvalue(result, i, 0));
2683 
2684  if (*(PQgetvalue(result, i, 1)) == 'f')
2685  appendPQExpBufferStr(&buf, " AS RESTRICTIVE");
2686 
2687  if (!PQgetisnull(result, i, 5))
2688  appendPQExpBuffer(&buf, " FOR %s",
2689  PQgetvalue(result, i, 5));
2690 
2691  if (!PQgetisnull(result, i, 2))
2692  {
2693  appendPQExpBuffer(&buf, "\n TO %s",
2694  PQgetvalue(result, i, 2));
2695  }
2696 
2697  if (!PQgetisnull(result, i, 3))
2698  appendPQExpBuffer(&buf, "\n USING (%s)",
2699  PQgetvalue(result, i, 3));
2700 
2701  if (!PQgetisnull(result, i, 4))
2702  appendPQExpBuffer(&buf, "\n WITH CHECK (%s)",
2703  PQgetvalue(result, i, 4));
2704 
2705  printTableAddFooter(&cont, buf.data);
2706  }
2707  PQclear(result);
2708  }
2709 
2710  /* print any extended statistics */
2711  if (pset.sversion >= 140000)
2712  {
2714  "SELECT oid, "
2715  "stxrelid::pg_catalog.regclass, "
2716  "stxnamespace::pg_catalog.regnamespace::pg_catalog.text AS nsp, "
2717  "stxname,\n"
2718  "pg_catalog.pg_get_statisticsobjdef_columns(oid) AS columns,\n"
2719  " 'd' = any(stxkind) AS ndist_enabled,\n"
2720  " 'f' = any(stxkind) AS deps_enabled,\n"
2721  " 'm' = any(stxkind) AS mcv_enabled,\n"
2722  "stxstattarget\n"
2723  "FROM pg_catalog.pg_statistic_ext\n"
2724  "WHERE stxrelid = '%s'\n"
2725  "ORDER BY nsp, stxname;",
2726  oid);
2727 
2728  result = PSQLexec(buf.data);
2729  if (!result)
2730  goto error_return;
2731  else
2732  tuples = PQntuples(result);
2733 
2734  if (tuples > 0)
2735  {
2736  printTableAddFooter(&cont, _("Statistics objects:"));
2737 
2738  for (i = 0; i < tuples; i++)
2739  {
2740  bool gotone = false;
2741  bool has_ndistinct;
2742  bool has_dependencies;
2743  bool has_mcv;
2744  bool has_all;
2745  bool has_some;
2746 
2747  has_ndistinct = (strcmp(PQgetvalue(result, i, 5), "t") == 0);
2748  has_dependencies = (strcmp(PQgetvalue(result, i, 6), "t") == 0);
2749  has_mcv = (strcmp(PQgetvalue(result, i, 7), "t") == 0);
2750 
2751  printfPQExpBuffer(&buf, " ");
2752 
2753  /* statistics object name (qualified with namespace) */
2754  appendPQExpBuffer(&buf, "\"%s.%s\"",
2755  PQgetvalue(result, i, 2),
2756  PQgetvalue(result, i, 3));
2757 
2758  /*
2759  * When printing kinds we ignore expression statistics,
2760  * which are used only internally and can't be specified
2761  * by user. We don't print the kinds when none are
2762  * specified (in which case it has to be statistics on a
2763  * single expr) or when all are specified (in which case
2764  * we assume it's expanded by CREATE STATISTICS).
2765  */
2766  has_all = (has_ndistinct && has_dependencies && has_mcv);
2767  has_some = (has_ndistinct || has_dependencies || has_mcv);
2768 
2769  if (has_some && !has_all)
2770  {
2771  appendPQExpBufferStr(&buf, " (");
2772 
2773  /* options */
2774  if (has_ndistinct)
2775  {
2776  appendPQExpBufferStr(&buf, "ndistinct");
2777  gotone = true;
2778  }
2779 
2780  if (has_dependencies)
2781  {
2782  appendPQExpBuffer(&buf, "%sdependencies", gotone ? ", " : "");
2783  gotone = true;
2784  }
2785 
2786  if (has_mcv)
2787  {
2788  appendPQExpBuffer(&buf, "%smcv", gotone ? ", " : "");
2789  }
2790 
2791  appendPQExpBufferChar(&buf, ')');
2792  }
2793 
2794  appendPQExpBuffer(&buf, " ON %s FROM %s",
2795  PQgetvalue(result, i, 4),
2796  PQgetvalue(result, i, 1));
2797 
2798  /* Show the stats target if it's not default */
2799  if (!PQgetisnull(result, i, 8) &&
2800  strcmp(PQgetvalue(result, i, 8), "-1") != 0)
2801  appendPQExpBuffer(&buf, "; STATISTICS %s",
2802  PQgetvalue(result, i, 8));
2803 
2804  printTableAddFooter(&cont, buf.data);
2805  }
2806  }
2807  PQclear(result);
2808  }
2809  else if (pset.sversion >= 100000)
2810  {
2812  "SELECT oid, "
2813  "stxrelid::pg_catalog.regclass, "
2814  "stxnamespace::pg_catalog.regnamespace AS nsp, "
2815  "stxname,\n"
2816  " (SELECT pg_catalog.string_agg(pg_catalog.quote_ident(attname),', ')\n"
2817  " FROM pg_catalog.unnest(stxkeys) s(attnum)\n"
2818  " JOIN pg_catalog.pg_attribute a ON (stxrelid = a.attrelid AND\n"
2819  " a.attnum = s.attnum AND NOT attisdropped)) AS columns,\n"
2820  " 'd' = any(stxkind) AS ndist_enabled,\n"
2821  " 'f' = any(stxkind) AS deps_enabled,\n"
2822  " 'm' = any(stxkind) AS mcv_enabled,\n");
2823 
2824  if (pset.sversion >= 130000)
2825  appendPQExpBufferStr(&buf, " stxstattarget\n");
2826  else
2827  appendPQExpBufferStr(&buf, " -1 AS stxstattarget\n");
2828  appendPQExpBuffer(&buf, "FROM pg_catalog.pg_statistic_ext\n"
2829  "WHERE stxrelid = '%s'\n"
2830  "ORDER BY 1;",
2831  oid);
2832 
2833  result = PSQLexec(buf.data);
2834  if (!result)
2835  goto error_return;
2836  else
2837  tuples = PQntuples(result);
2838 
2839  if (tuples > 0)
2840  {
2841  printTableAddFooter(&cont, _("Statistics objects:"));
2842 
2843  for (i = 0; i < tuples; i++)
2844  {
2845  bool gotone = false;
2846 
2847  printfPQExpBuffer(&buf, " ");
2848 
2849  /* statistics object name (qualified with namespace) */
2850  appendPQExpBuffer(&buf, "\"%s.%s\" (",
2851  PQgetvalue(result, i, 2),
2852  PQgetvalue(result, i, 3));
2853 
2854  /* options */
2855  if (strcmp(PQgetvalue(result, i, 5), "t") == 0)
2856  {
2857  appendPQExpBufferStr(&buf, "ndistinct");
2858  gotone = true;
2859  }
2860 
2861  if (strcmp(PQgetvalue(result, i, 6), "t") == 0)
2862  {
2863  appendPQExpBuffer(&buf, "%sdependencies", gotone ? ", " : "");
2864  gotone = true;
2865  }
2866 
2867  if (strcmp(PQgetvalue(result, i, 7), "t") == 0)
2868  {
2869  appendPQExpBuffer(&buf, "%smcv", gotone ? ", " : "");
2870  }
2871 
2872  appendPQExpBuffer(&buf, ") ON %s FROM %s",
2873  PQgetvalue(result, i, 4),
2874  PQgetvalue(result, i, 1));
2875 
2876  /* Show the stats target if it's not default */
2877  if (strcmp(PQgetvalue(result, i, 8), "-1") != 0)
2878  appendPQExpBuffer(&buf, "; STATISTICS %s",
2879  PQgetvalue(result, i, 8));
2880 
2881  printTableAddFooter(&cont, buf.data);
2882  }
2883  }
2884  PQclear(result);
2885  }
2886 
2887  /* print rules */
2888  if (tableinfo.hasrules && tableinfo.relkind != RELKIND_MATVIEW)
2889  {
2891  "SELECT r.rulename, trim(trailing ';' from pg_catalog.pg_get_ruledef(r.oid, true)), "
2892  "ev_enabled\n"
2893  "FROM pg_catalog.pg_rewrite r\n"
2894  "WHERE r.ev_class = '%s' ORDER BY 1;",
2895  oid);
2896  result = PSQLexec(buf.data);
2897  if (!result)
2898  goto error_return;
2899  else
2900  tuples = PQntuples(result);
2901 
2902  if (tuples > 0)
2903  {
2904  bool have_heading;
2905  int category;
2906 
2907  for (category = 0; category < 4; category++)
2908  {
2909  have_heading = false;
2910 
2911  for (i = 0; i < tuples; i++)
2912  {
2913  const char *ruledef;
2914  bool list_rule = false;
2915 
2916  switch (category)
2917  {
2918  case 0:
2919  if (*PQgetvalue(result, i, 2) == 'O')
2920  list_rule = true;
2921  break;
2922  case 1:
2923  if (*PQgetvalue(result, i, 2) == 'D')
2924  list_rule = true;
2925  break;
2926  case 2:
2927  if (*PQgetvalue(result, i, 2) == 'A')
2928  list_rule = true;
2929  break;
2930  case 3:
2931  if (*PQgetvalue(result, i, 2) == 'R')
2932  list_rule = true;
2933  break;
2934  }
2935  if (!list_rule)
2936  continue;
2937 
2938  if (!have_heading)
2939  {
2940  switch (category)
2941  {
2942  case 0:
2943  printfPQExpBuffer(&buf, _("Rules:"));
2944  break;
2945  case 1:
2946  printfPQExpBuffer(&buf, _("Disabled rules:"));
2947  break;
2948  case 2:
2949  printfPQExpBuffer(&buf, _("Rules firing always:"));
2950  break;
2951  case 3:
2952  printfPQExpBuffer(&buf, _("Rules firing on replica only:"));
2953  break;
2954  }
2955  printTableAddFooter(&cont, buf.data);
2956  have_heading = true;
2957  }
2958 
2959  /* Everything after "CREATE RULE" is echoed verbatim */
2960  ruledef = PQgetvalue(result, i, 1);
2961  ruledef += 12;
2962  printfPQExpBuffer(&buf, " %s", ruledef);
2963  printTableAddFooter(&cont, buf.data);
2964  }
2965  }
2966  }
2967  PQclear(result);
2968  }
2969 
2970  /* print any publications */
2971  if (pset.sversion >= 100000)
2972  {
2973  if (pset.sversion >= 150000)
2974  {
2976  "SELECT pubname\n"
2977  " , NULL\n"
2978  " , NULL\n"
2979  "FROM pg_catalog.pg_publication p\n"
2980  " JOIN pg_catalog.pg_publication_namespace pn ON p.oid = pn.pnpubid\n"
2981  " JOIN pg_catalog.pg_class pc ON pc.relnamespace = pn.pnnspid\n"
2982  "WHERE pc.oid ='%s' and pg_catalog.pg_relation_is_publishable('%s')\n"
2983  "UNION\n"
2984  "SELECT pubname\n"
2985  " , pg_get_expr(pr.prqual, c.oid)\n"
2986  " , (CASE WHEN pr.prattrs IS NOT NULL THEN\n"
2987  " (SELECT string_agg(attname, ', ')\n"
2988  " FROM pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
2989  " pg_catalog.pg_attribute\n"
2990  " WHERE attrelid = pr.prrelid AND attnum = prattrs[s])\n"
2991  " ELSE NULL END) "
2992  "FROM pg_catalog.pg_publication p\n"
2993  " JOIN pg_catalog.pg_publication_rel pr ON p.oid = pr.prpubid\n"
2994  " JOIN pg_catalog.pg_class c ON c.oid = pr.prrelid\n"
2995  "WHERE pr.prrelid = '%s'\n"
2996  "UNION\n"
2997  "SELECT pubname\n"
2998  " , NULL\n"
2999  " , NULL\n"
3000  "FROM pg_catalog.pg_publication p\n"
3001  "WHERE p.puballtables AND pg_catalog.pg_relation_is_publishable('%s')\n"
3002  "ORDER BY 1;",
3003  oid, oid, oid, oid);
3004  }
3005  else
3006  {
3008  "SELECT pubname\n"
3009  " , NULL\n"
3010  " , NULL\n"
3011  "FROM pg_catalog.pg_publication p\n"
3012  "JOIN pg_catalog.pg_publication_rel pr ON p.oid = pr.prpubid\n"
3013  "WHERE pr.prrelid = '%s'\n"
3014  "UNION ALL\n"
3015  "SELECT pubname\n"
3016  " , NULL\n"
3017  " , NULL\n"
3018  "FROM pg_catalog.pg_publication p\n"
3019  "WHERE p.puballtables AND pg_catalog.pg_relation_is_publishable('%s')\n"
3020  "ORDER BY 1;",
3021  oid, oid);
3022  }
3023 
3024  result = PSQLexec(buf.data);
3025  if (!result)
3026  goto error_return;
3027  else
3028  tuples = PQntuples(result);
3029 
3030  if (tuples > 0)
3031  printTableAddFooter(&cont, _("Publications:"));
3032 
3033  /* Might be an empty set - that's ok */
3034  for (i = 0; i < tuples; i++)
3035  {
3036  printfPQExpBuffer(&buf, " \"%s\"",
3037  PQgetvalue(result, i, 0));
3038 
3039  /* column list (if any) */
3040  if (!PQgetisnull(result, i, 2))
3041  appendPQExpBuffer(&buf, " (%s)",
3042  PQgetvalue(result, i, 2));
3043 
3044  /* row filter (if any) */
3045  if (!PQgetisnull(result, i, 1))
3046  appendPQExpBuffer(&buf, " WHERE %s",
3047  PQgetvalue(result, i, 1));
3048 
3049  printTableAddFooter(&cont, buf.data);
3050  }
3051  PQclear(result);
3052  }
3053  }
3054 
3055  /* Get view_def if table is a view or materialized view */
3056  if ((tableinfo.relkind == RELKIND_VIEW ||
3057  tableinfo.relkind == RELKIND_MATVIEW) && verbose)
3058  {
3059  PGresult *result;
3060 
3062  "SELECT pg_catalog.pg_get_viewdef('%s'::pg_catalog.oid, true);",
3063  oid);
3064  result = PSQLexec(buf.data);
3065  if (!result)
3066  goto error_return;
3067 
3068  if (PQntuples(result) > 0)
3069  view_def = pg_strdup(PQgetvalue(result, 0, 0));
3070 
3071  PQclear(result);
3072  }
3073 
3074  if (view_def)
3075  {
3076  PGresult *result = NULL;
3077 
3078  /* Footer information about a view */
3079  printTableAddFooter(&cont, _("View definition:"));
3080  printTableAddFooter(&cont, view_def);
3081 
3082  /* print rules */
3083  if (tableinfo.hasrules)
3084  {
3086  "SELECT r.rulename, trim(trailing ';' from pg_catalog.pg_get_ruledef(r.oid, true))\n"
3087  "FROM pg_catalog.pg_rewrite r\n"
3088  "WHERE r.ev_class = '%s' AND r.rulename != '_RETURN' ORDER BY 1;",
3089  oid);
3090  result = PSQLexec(buf.data);
3091  if (!result)
3092  goto error_return;
3093 
3094  if (PQntuples(result) > 0)
3095  {
3096  printTableAddFooter(&cont, _("Rules:"));
3097  for (i = 0; i < PQntuples(result); i++)
3098  {
3099  const char *ruledef;
3100 
3101  /* Everything after "CREATE RULE" is echoed verbatim */
3102  ruledef = PQgetvalue(result, i, 1);
3103  ruledef += 12;
3104 
3105  printfPQExpBuffer(&buf, " %s", ruledef);
3106  printTableAddFooter(&cont, buf.data);
3107  }
3108  }
3109  PQclear(result);
3110  }
3111  }
3112 
3113  /*
3114  * Print triggers next, if any (but only user-defined triggers). This
3115  * could apply to either a table or a view.
3116  */
3117  if (tableinfo.hastriggers)
3118  {
3119  PGresult *result;
3120  int tuples;
3121 
3123  "SELECT t.tgname, "
3124  "pg_catalog.pg_get_triggerdef(t.oid, true), "
3125  "t.tgenabled, t.tgisinternal,\n");
3126 
3127  /*
3128  * Detect whether each trigger is inherited, and if so, get the name
3129  * of the topmost table it's inherited from. We have no easy way to
3130  * do that pre-v13, for lack of the tgparentid column. Even with
3131  * tgparentid, a straightforward search for the topmost parent would
3132  * require a recursive CTE, which seems unduly expensive. We cheat a
3133  * bit by assuming parent triggers will match by tgname; then, joining
3134  * with pg_partition_ancestors() allows the planner to make use of
3135  * pg_trigger_tgrelid_tgname_index if it wishes. We ensure we find
3136  * the correct topmost parent by stopping at the first-in-partition-
3137  * ancestry-order trigger that has tgparentid = 0. (There might be
3138  * unrelated, non-inherited triggers with the same name further up the
3139  * stack, so this is important.)
3140  */
3141  if (pset.sversion >= 130000)
3143  " CASE WHEN t.tgparentid != 0 THEN\n"
3144  " (SELECT u.tgrelid::pg_catalog.regclass\n"
3145  " FROM pg_catalog.pg_trigger AS u,\n"
3146  " pg_catalog.pg_partition_ancestors(t.tgrelid) WITH ORDINALITY AS a(relid, depth)\n"
3147  " WHERE u.tgname = t.tgname AND u.tgrelid = a.relid\n"
3148  " AND u.tgparentid = 0\n"
3149  " ORDER BY a.depth LIMIT 1)\n"
3150  " END AS parent\n");
3151  else
3152  appendPQExpBufferStr(&buf, " NULL AS parent\n");
3153 
3155  "FROM pg_catalog.pg_trigger t\n"
3156  "WHERE t.tgrelid = '%s' AND ",
3157  oid);
3158 
3159  /*
3160  * tgisinternal is set true for inherited triggers of partitions in
3161  * servers between v11 and v14, though these must still be shown to
3162  * the user. So we use another property that is true for such
3163  * inherited triggers to avoid them being hidden, which is their
3164  * dependence on another trigger.
3165  */
3166  if (pset.sversion >= 110000 && pset.sversion < 150000)
3167  appendPQExpBufferStr(&buf, "(NOT t.tgisinternal OR (t.tgisinternal AND t.tgenabled = 'D') \n"
3168  " OR EXISTS (SELECT 1 FROM pg_catalog.pg_depend WHERE objid = t.oid \n"
3169  " AND refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass))");
3170  else
3171  /* display/warn about disabled internal triggers */
3172  appendPQExpBufferStr(&buf, "(NOT t.tgisinternal OR (t.tgisinternal AND t.tgenabled = 'D'))");
3173  appendPQExpBufferStr(&buf, "\nORDER BY 1;");
3174 
3175  result = PSQLexec(buf.data);
3176  if (!result)
3177  goto error_return;
3178  else
3179  tuples = PQntuples(result);
3180 
3181  if (tuples > 0)
3182  {
3183  bool have_heading;
3184  int category;
3185 
3186  /*
3187  * split the output into 4 different categories. Enabled triggers,
3188  * disabled triggers and the two special ALWAYS and REPLICA
3189  * configurations.
3190  */
3191  for (category = 0; category <= 4; category++)
3192  {
3193  have_heading = false;
3194  for (i = 0; i < tuples; i++)
3195  {
3196  bool list_trigger;
3197  const char *tgdef;
3198  const char *usingpos;
3199  const char *tgenabled;
3200  const char *tgisinternal;
3201 
3202  /*
3203  * Check if this trigger falls into the current category
3204  */
3205  tgenabled = PQgetvalue(result, i, 2);
3206  tgisinternal = PQgetvalue(result, i, 3);
3207  list_trigger = false;
3208  switch (category)
3209  {
3210  case 0:
3211  if (*tgenabled == 'O' || *tgenabled == 't')
3212  list_trigger = true;
3213  break;
3214  case 1:
3215  if ((*tgenabled == 'D' || *tgenabled == 'f') &&
3216  *tgisinternal == 'f')
3217  list_trigger = true;
3218  break;
3219  case 2:
3220  if ((*tgenabled == 'D' || *tgenabled == 'f') &&
3221  *tgisinternal == 't')
3222  list_trigger = true;
3223  break;
3224  case 3:
3225  if (*tgenabled == 'A')
3226  list_trigger = true;
3227  break;
3228  case 4:
3229  if (*tgenabled == 'R')
3230  list_trigger = true;
3231  break;
3232  }
3233  if (list_trigger == false)
3234  continue;
3235 
3236  /* Print the category heading once */
3237  if (have_heading == false)
3238  {
3239  switch (category)
3240  {
3241  case 0:
3242  printfPQExpBuffer(&buf, _("Triggers:"));
3243  break;
3244  case 1:
3245  printfPQExpBuffer(&buf, _("Disabled user triggers:"));
3246  break;
3247  case 2:
3248  printfPQExpBuffer(&buf, _("Disabled internal triggers:"));
3249  break;
3250  case 3:
3251  printfPQExpBuffer(&buf, _("Triggers firing always:"));
3252  break;
3253  case 4:
3254  printfPQExpBuffer(&buf, _("Triggers firing on replica only:"));
3255  break;
3256  }
3257  printTableAddFooter(&cont, buf.data);
3258  have_heading = true;
3259  }
3260 
3261  /* Everything after "TRIGGER" is echoed verbatim */
3262  tgdef = PQgetvalue(result, i, 1);
3263  usingpos = strstr(tgdef, " TRIGGER ");
3264  if (usingpos)
3265  tgdef = usingpos + 9;
3266 
3267  printfPQExpBuffer(&buf, " %s", tgdef);
3268 
3269  /* Visually distinguish inherited triggers */
3270  if (!PQgetisnull(result, i, 4))
3271  appendPQExpBuffer(&buf, ", ON TABLE %s",
3272  PQgetvalue(result, i, 4));
3273 
3274  printTableAddFooter(&cont, buf.data);
3275  }
3276  }
3277  }
3278  PQclear(result);
3279  }
3280 
3281  /*
3282  * Finish printing the footer information about a table.
3283  */
3284  if (tableinfo.relkind == RELKIND_RELATION ||
3285  tableinfo.relkind == RELKIND_MATVIEW ||
3286  tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
3287  tableinfo.relkind == RELKIND_PARTITIONED_TABLE ||
3288  tableinfo.relkind == RELKIND_PARTITIONED_INDEX ||
3289  tableinfo.relkind == RELKIND_TOASTVALUE)
3290  {
3291  bool is_partitioned;
3292  PGresult *result;
3293  int tuples;
3294 
3295  /* simplify some repeated tests below */
3296  is_partitioned = (tableinfo.relkind == RELKIND_PARTITIONED_TABLE ||
3297  tableinfo.relkind == RELKIND_PARTITIONED_INDEX);
3298 
3299  /* print foreign server name */
3300  if (tableinfo.relkind == RELKIND_FOREIGN_TABLE)
3301  {
3302  char *ftoptions;
3303 
3304  /* Footer information about foreign table */
3306  "SELECT s.srvname,\n"
3307  " pg_catalog.array_to_string(ARRAY(\n"
3308  " SELECT pg_catalog.quote_ident(option_name)"
3309  " || ' ' || pg_catalog.quote_literal(option_value)\n"
3310  " FROM pg_catalog.pg_options_to_table(ftoptions)), ', ')\n"
3311  "FROM pg_catalog.pg_foreign_table f,\n"
3312  " pg_catalog.pg_foreign_server s\n"
3313  "WHERE f.ftrelid = '%s' AND s.oid = f.ftserver;",
3314  oid);
3315  result = PSQLexec(buf.data);
3316  if (!result)
3317  goto error_return;
3318  else if (PQntuples(result) != 1)
3319  {
3320  PQclear(result);
3321  goto error_return;
3322  }
3323 
3324  /* Print server name */
3325  printfPQExpBuffer(&buf, _("Server: %s"),
3326  PQgetvalue(result, 0, 0));
3327  printTableAddFooter(&cont, buf.data);
3328 
3329  /* Print per-table FDW options, if any */
3330  ftoptions = PQgetvalue(result, 0, 1);
3331  if (ftoptions && ftoptions[0] != '\0')
3332  {
3333  printfPQExpBuffer(&buf, _("FDW options: (%s)"), ftoptions);
3334  printTableAddFooter(&cont, buf.data);
3335  }
3336  PQclear(result);
3337  }
3338 
3339  /* print tables inherited from (exclude partitioned parents) */
3341  "SELECT c.oid::pg_catalog.regclass\n"
3342  "FROM pg_catalog.pg_class c, pg_catalog.pg_inherits i\n"
3343  "WHERE c.oid = i.inhparent AND i.inhrelid = '%s'\n"
3344  " AND c.relkind != " CppAsString2(RELKIND_PARTITIONED_TABLE)
3345  " AND c.relkind != " CppAsString2(RELKIND_PARTITIONED_INDEX)
3346  "\nORDER BY inhseqno;",
3347  oid);
3348 
3349  result = PSQLexec(buf.data);
3350  if (!result)
3351  goto error_return;
3352  else
3353  {
3354  const char *s = _("Inherits");
3355  int sw = pg_wcswidth(s, strlen(s), pset.encoding);
3356 
3357  tuples = PQntuples(result);
3358 
3359  for (i = 0; i < tuples; i++)
3360  {
3361  if (i == 0)
3362  printfPQExpBuffer(&buf, "%s: %s",
3363  s, PQgetvalue(result, i, 0));
3364  else
3365  printfPQExpBuffer(&buf, "%*s %s",
3366  sw, "", PQgetvalue(result, i, 0));
3367  if (i < tuples - 1)
3368  appendPQExpBufferChar(&buf, ',');
3369 
3370  printTableAddFooter(&cont, buf.data);
3371  }
3372 
3373  PQclear(result);
3374  }
3375 
3376  /* print child tables (with additional info if partitions) */
3377  if (pset.sversion >= 140000)
3379  "SELECT c.oid::pg_catalog.regclass, c.relkind,"
3380  " inhdetachpending,"
3381  " pg_catalog.pg_get_expr(c.relpartbound, c.oid)\n"
3382  "FROM pg_catalog.pg_class c, pg_catalog.pg_inherits i\n"
3383  "WHERE c.oid = i.inhrelid AND i.inhparent = '%s'\n"
3384  "ORDER BY pg_catalog.pg_get_expr(c.relpartbound, c.oid) = 'DEFAULT',"
3385  " c.oid::pg_catalog.regclass::pg_catalog.text;",
3386  oid);
3387  else if (pset.sversion >= 100000)
3389  "SELECT c.oid::pg_catalog.regclass, c.relkind,"
3390  " false AS inhdetachpending,"
3391  " pg_catalog.pg_get_expr(c.relpartbound, c.oid)\n"
3392  "FROM pg_catalog.pg_class c, pg_catalog.pg_inherits i\n"
3393  "WHERE c.oid = i.inhrelid AND i.inhparent = '%s'\n"
3394  "ORDER BY pg_catalog.pg_get_expr(c.relpartbound, c.oid) = 'DEFAULT',"
3395  " c.oid::pg_catalog.regclass::pg_catalog.text;",
3396  oid);
3397  else
3399  "SELECT c.oid::pg_catalog.regclass, c.relkind,"
3400  " false AS inhdetachpending, NULL\n"
3401  "FROM pg_catalog.pg_class c, pg_catalog.pg_inherits i\n"
3402  "WHERE c.oid = i.inhrelid AND i.inhparent = '%s'\n"
3403  "ORDER BY c.oid::pg_catalog.regclass::pg_catalog.text;",
3404  oid);
3405 
3406  result = PSQLexec(buf.data);
3407  if (!result)
3408  goto error_return;
3409  tuples = PQntuples(result);
3410 
3411  /*
3412  * For a partitioned table with no partitions, always print the number
3413  * of partitions as zero, even when verbose output is expected.
3414  * Otherwise, we will not print "Partitions" section for a partitioned
3415  * table without any partitions.
3416  */
3417  if (is_partitioned && tuples == 0)
3418  {
3419  printfPQExpBuffer(&buf, _("Number of partitions: %d"), tuples);
3420  printTableAddFooter(&cont, buf.data);
3421  }
3422  else if (!verbose)
3423  {
3424  /* print the number of child tables, if any */
3425  if (tuples > 0)
3426  {
3427  if (is_partitioned)
3428  printfPQExpBuffer(&buf, _("Number of partitions: %d (Use \\d+ to list them.)"), tuples);
3429  else
3430  printfPQExpBuffer(&buf, _("Number of child tables: %d (Use \\d+ to list them.)"), tuples);
3431  printTableAddFooter(&cont, buf.data);
3432  }
3433  }
3434  else
3435  {
3436  /* display the list of child tables */
3437  const char *ct = is_partitioned ? _("Partitions") : _("Child tables");
3438  int ctw = pg_wcswidth(ct, strlen(ct), pset.encoding);
3439 
3440  for (i = 0; i < tuples; i++)
3441  {
3442  char child_relkind = *PQgetvalue(result, i, 1);
3443 
3444  if (i == 0)
3445  printfPQExpBuffer(&buf, "%s: %s",
3446  ct, PQgetvalue(result, i, 0));
3447  else
3448  printfPQExpBuffer(&buf, "%*s %s",
3449  ctw, "", PQgetvalue(result, i, 0));
3450  if (!PQgetisnull(result, i, 3))
3451  appendPQExpBuffer(&buf, " %s", PQgetvalue(result, i, 3));
3452  if (child_relkind == RELKIND_PARTITIONED_TABLE ||
3453  child_relkind == RELKIND_PARTITIONED_INDEX)
3454  appendPQExpBufferStr(&buf, ", PARTITIONED");
3455  else if (child_relkind == RELKIND_FOREIGN_TABLE)
3456  appendPQExpBufferStr(&buf, ", FOREIGN");
3457  if (strcmp(PQgetvalue(result, i, 2), "t") == 0)
3458  appendPQExpBufferStr(&buf, " (DETACH PENDING)");
3459  if (i < tuples - 1)
3460  appendPQExpBufferChar(&buf, ',');
3461 
3462  printTableAddFooter(&cont, buf.data);
3463  }
3464  }
3465  PQclear(result);
3466 
3467  /* Table type */
3468  if (tableinfo.reloftype)
3469  {
3470  printfPQExpBuffer(&buf, _("Typed table of type: %s"), tableinfo.reloftype);
3471  printTableAddFooter(&cont, buf.data);
3472  }
3473 
3474  if (verbose &&
3475  (tableinfo.relkind == RELKIND_RELATION ||
3476  tableinfo.relkind == RELKIND_MATVIEW) &&
3477 
3478  /*
3479  * No need to display default values; we already display a REPLICA
3480  * IDENTITY marker on indexes.
3481  */
3482  tableinfo.relreplident != 'i' &&
3483  ((strcmp(schemaname, "pg_catalog") != 0 && tableinfo.relreplident != 'd') ||
3484  (strcmp(schemaname, "pg_catalog") == 0 && tableinfo.relreplident != 'n')))
3485  {
3486  const char *s = _("Replica Identity");
3487 
3488  printfPQExpBuffer(&buf, "%s: %s",
3489  s,
3490  tableinfo.relreplident == 'f' ? "FULL" :
3491  tableinfo.relreplident == 'n' ? "NOTHING" :
3492  "???");
3493 
3494  printTableAddFooter(&cont, buf.data);
3495  }
3496 
3497  /* OIDs, if verbose and not a materialized view */
3498  if (verbose && tableinfo.relkind != RELKIND_MATVIEW && tableinfo.hasoids)
3499  printTableAddFooter(&cont, _("Has OIDs: yes"));
3500 
3501  /* Tablespace info */
3502  add_tablespace_footer(&cont, tableinfo.relkind, tableinfo.tablespace,
3503  true);
3504 
3505  /* Access method info */
3506  if (verbose && tableinfo.relam != NULL && !pset.hide_tableam)
3507  {
3508  printfPQExpBuffer(&buf, _("Access method: %s"), tableinfo.relam);
3509  printTableAddFooter(&cont, buf.data);
3510  }
3511  }
3512 
3513  /* reloptions, if verbose */
3514  if (verbose &&
3515  tableinfo.reloptions && tableinfo.reloptions[0] != '\0')
3516  {
3517  const char *t = _("Options");
3518 
3519  printfPQExpBuffer(&buf, "%s: %s", t, tableinfo.reloptions);
3520  printTableAddFooter(&cont, buf.data);
3521  }
3522 
3523  printTable(&cont, pset.queryFout, false, pset.logfile);
3524 
3525  retval = true;
3526 
3527 error_return:
3528 
3529  /* clean up */
3530  if (printTableInitialized)
3531  printTableCleanup(&cont);
3532  termPQExpBuffer(&buf);
3533  termPQExpBuffer(&title);
3535 
3536  free(view_def);
3537 
3538  PQclear(res);
3539 
3540  return retval;
3541 }
3542 
3543 /*
3544  * Add a tablespace description to a footer. If 'newline' is true, it is added
3545  * in a new line; otherwise it's appended to the current value of the last
3546  * footer.
3547  */
3548 static void
3549 add_tablespace_footer(printTableContent *const cont, char relkind,
3550  Oid tablespace, const bool newline)
3551 {
3552  /* relkinds for which we support tablespaces */
3553  if (relkind == RELKIND_RELATION ||
3554  relkind == RELKIND_MATVIEW ||
3555  relkind == RELKIND_INDEX ||
3556  relkind == RELKIND_PARTITIONED_TABLE ||
3557  relkind == RELKIND_PARTITIONED_INDEX ||
3558  relkind == RELKIND_TOASTVALUE)
3559  {
3560  /*
3561  * We ignore the database default tablespace so that users not using
3562  * tablespaces don't need to know about them.
3563  */
3564  if (tablespace != 0)
3565  {
3566  PGresult *result = NULL;
3568 
3569  initPQExpBuffer(&buf);
3571  "SELECT spcname FROM pg_catalog.pg_tablespace\n"
3572  "WHERE oid = '%u';", tablespace);
3573  result = PSQLexec(buf.data);
3574  if (!result)
3575  {
3576  termPQExpBuffer(&buf);
3577  return;
3578  }
3579  /* Should always be the case, but.... */
3580  if (PQntuples(result) > 0)
3581  {
3582  if (newline)
3583  {
3584  /* Add the tablespace as a new footer */
3585  printfPQExpBuffer(&buf, _("Tablespace: \"%s\""),
3586  PQgetvalue(result, 0, 0));
3587  printTableAddFooter(cont, buf.data);
3588  }
3589  else
3590  {
3591  /* Append the tablespace to the latest footer */
3592  printfPQExpBuffer(&buf, "%s", cont->footer->data);
3593 
3594  /*-------
3595  translator: before this string there's an index description like
3596  '"foo_pkey" PRIMARY KEY, btree (a)' */
3597  appendPQExpBuffer(&buf, _(", tablespace \"%s\""),
3598  PQgetvalue(result, 0, 0));
3599  printTableSetFooter(cont, buf.data);
3600  }
3601  }
3602  PQclear(result);
3603  termPQExpBuffer(&buf);
3604  }
3605  }
3606 }
3607 
3608 /*
3609  * \du or \dg
3610  *
3611  * Describes roles. Any schema portion of the pattern is ignored.
3612  */
3613 bool
3614 describeRoles(const char *pattern, bool verbose, bool showSystem)
3615 {
3617  PGresult *res;
3618  printTableContent cont;
3619  printTableOpt myopt = pset.popt.topt;
3620  int ncols = 2;
3621  int nrows = 0;
3622  int i;
3623  int conns;
3624  const char align = 'l';
3625  char **attr;
3626 
3627  myopt.default_footer = false;
3628 
3629  initPQExpBuffer(&buf);
3630 
3632  "SELECT r.rolname, r.rolsuper, r.rolinherit,\n"
3633  " r.rolcreaterole, r.rolcreatedb, r.rolcanlogin,\n"
3634  " r.rolconnlimit, r.rolvaliduntil");
3635 
3636  if (verbose)
3637  {
3638  appendPQExpBufferStr(&buf, "\n, pg_catalog.shobj_description(r.oid, 'pg_authid') AS description");
3639  ncols++;
3640  }
3641  appendPQExpBufferStr(&buf, "\n, r.rolreplication");
3642 
3643  if (pset.sversion >= 90500)
3644  {
3645  appendPQExpBufferStr(&buf, "\n, r.rolbypassrls");
3646  }
3647 
3648  appendPQExpBufferStr(&buf, "\nFROM pg_catalog.pg_roles r\n");
3649 
3650  if (!showSystem && !pattern)
3651  appendPQExpBufferStr(&buf, "WHERE r.rolname !~ '^pg_'\n");
3652 
3653  if (!validateSQLNamePattern(&buf, pattern, false, false,
3654  NULL, "r.rolname", NULL, NULL,
3655  NULL, 1))
3656  {
3657  termPQExpBuffer(&buf);
3658  return false;
3659  }
3660 
3661  appendPQExpBufferStr(&buf, "ORDER BY 1;");
3662 
3663  res = PSQLexec(buf.data);
3664  if (!res)
3665  return false;
3666 
3667  nrows = PQntuples(res);
3668  attr = pg_malloc0((nrows + 1) * sizeof(*attr));
3669 
3670  printTableInit(&cont, &myopt, _("List of roles"), ncols, nrows);
3671 
3672  printTableAddHeader(&cont, gettext_noop("Role name"), true, align);
3673  printTableAddHeader(&cont, gettext_noop("Attributes"), true, align);
3674 
3675  if (verbose)
3676  printTableAddHeader(&cont, gettext_noop("Description"), true, align);
3677 
3678  for (i = 0; i < nrows; i++)
3679  {
3680  printTableAddCell(&cont, PQgetvalue(res, i, 0), false, false);
3681 
3683  if (strcmp(PQgetvalue(res, i, 1), "t") == 0)
3684  add_role_attribute(&buf, _("Superuser"));
3685 
3686  if (strcmp(PQgetvalue(res, i, 2), "t") != 0)
3687  add_role_attribute(&buf, _("No inheritance"));
3688 
3689  if (strcmp(PQgetvalue(res, i, 3), "t") == 0)
3690  add_role_attribute(&buf, _("Create role"));
3691 
3692  if (strcmp(PQgetvalue(res, i, 4), "t") == 0)
3693  add_role_attribute(&buf, _("Create DB"));
3694 
3695  if (strcmp(PQgetvalue(res, i, 5), "t") != 0)
3696  add_role_attribute(&buf, _("Cannot login"));
3697 
3698  if (strcmp(PQgetvalue(res, i, (verbose ? 9 : 8)), "t") == 0)
3699  add_role_attribute(&buf, _("Replication"));
3700 
3701  if (pset.sversion >= 90500)
3702  if (strcmp(PQgetvalue(res, i, (verbose ? 10 : 9)), "t") == 0)
3703  add_role_attribute(&buf, _("Bypass RLS"));
3704 
3705  conns = atoi(PQgetvalue(res, i, 6));
3706  if (conns >= 0)
3707  {
3708  if (buf.len > 0)
3709  appendPQExpBufferChar(&buf, '\n');
3710 
3711  if (conns == 0)
3712  appendPQExpBufferStr(&buf, _("No connections"));
3713  else
3714  appendPQExpBuffer(&buf, ngettext("%d connection",
3715  "%d connections",
3716  conns),
3717  conns);
3718  }
3719 
3720  if (strcmp(PQgetvalue(res, i, 7), "") != 0)
3721  {
3722  if (buf.len > 0)
3723  appendPQExpBufferChar(&buf, '\n');
3724  appendPQExpBufferStr(&buf, _("Password valid until "));
3726  }
3727 
3728  attr[i] = pg_strdup(buf.data);
3729 
3730  printTableAddCell(&cont, attr[i], false, false);
3731 
3732  if (verbose)
3733  printTableAddCell(&cont, PQgetvalue(res, i, 8), false, false);
3734  }
3735  termPQExpBuffer(&buf);
3736 
3737  printTable(&cont, pset.queryFout, false, pset.logfile);
3738  printTableCleanup(&cont);
3739 
3740  for (i = 0; i < nrows; i++)
3741  free(attr[i]);
3742  free(attr);
3743 
3744  PQclear(res);
3745  return true;
3746 }
3747 
3748 static void
3750 {
3751  if (buf->len > 0)
3752  appendPQExpBufferStr(buf, ", ");
3753 
3755 }
3756 
3757 /*
3758  * \drds
3759  */
3760 bool
3761 listDbRoleSettings(const char *pattern, const char *pattern2)
3762 {
3764  PGresult *res;
3765  printQueryOpt myopt = pset.popt;
3766  bool havewhere;
3767 
3768  initPQExpBuffer(&buf);
3769 
3770  printfPQExpBuffer(&buf, "SELECT rolname AS \"%s\", datname AS \"%s\",\n"
3771  "pg_catalog.array_to_string(setconfig, E'\\n') AS \"%s\"\n"
3772  "FROM pg_catalog.pg_db_role_setting s\n"
3773  "LEFT JOIN pg_catalog.pg_database d ON d.oid = setdatabase\n"
3774  "LEFT JOIN pg_catalog.pg_roles r ON r.oid = setrole\n",
3775  gettext_noop("Role"),
3776  gettext_noop("Database"),
3777  gettext_noop("Settings"));
3778  if (!validateSQLNamePattern(&buf, pattern, false, false,
3779  NULL, "r.rolname", NULL, NULL, &havewhere, 1))
3780  goto error_return;
3781  if (!validateSQLNamePattern(&buf, pattern2, havewhere, false,
3782  NULL, "d.datname", NULL, NULL,
3783  NULL, 1))
3784  goto error_return;
3785  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
3786 
3787  res = PSQLexec(buf.data);
3788  termPQExpBuffer(&buf);
3789  if (!res)
3790  return false;
3791 
3792  /*
3793  * Most functions in this file are content to print an empty table when
3794  * there are no matching objects. We intentionally deviate from that
3795  * here, but only in !quiet mode, because of the possibility that the user
3796  * is confused about what the two pattern arguments mean.
3797  */
3798  if (PQntuples(res) == 0 && !pset.quiet)
3799  {
3800  if (pattern && pattern2)
3801  pg_log_error("Did not find any settings for role \"%s\" and database \"%s\".",
3802  pattern, pattern2);
3803  else if (pattern)
3804  pg_log_error("Did not find any settings for role \"%s\".",
3805  pattern);
3806  else
3807  pg_log_error("Did not find any settings.");
3808  }
3809  else
3810  {
3811  myopt.title = _("List of settings");
3812  myopt.translate_header = true;
3813 
3814  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
3815  }
3816 
3817  PQclear(res);
3818  return true;
3819 
3820 error_return:
3821  termPQExpBuffer(&buf);
3822  return false;
3823 }
3824 
3825 /*
3826  * \drg
3827  * Describes role grants.
3828  */
3829 bool
3830 describeRoleGrants(const char *pattern, bool showSystem)
3831 {
3833  PGresult *res;
3834  printQueryOpt myopt = pset.popt;
3835 
3836  initPQExpBuffer(&buf);
3838  "SELECT m.rolname AS \"%s\", r.rolname AS \"%s\",\n"
3839  " pg_catalog.concat_ws(', ',\n",
3840  gettext_noop("Role name"),
3841  gettext_noop("Member of"));
3842 
3843  if (pset.sversion >= 160000)
3845  " CASE WHEN pam.admin_option THEN 'ADMIN' END,\n"
3846  " CASE WHEN pam.inherit_option THEN 'INHERIT' END,\n"
3847  " CASE WHEN pam.set_option THEN 'SET' END\n");
3848  else
3850  " CASE WHEN pam.admin_option THEN 'ADMIN' END,\n"
3851  " CASE WHEN m.rolinherit THEN 'INHERIT' END,\n"
3852  " 'SET'\n");
3853 
3855  " ) AS \"%s\",\n"
3856  " g.rolname AS \"%s\"\n",
3857  gettext_noop("Options"),
3858  gettext_noop("Grantor"));
3859 
3861  "FROM pg_catalog.pg_roles m\n"
3862  " JOIN pg_catalog.pg_auth_members pam ON (pam.member = m.oid)\n"
3863  " LEFT JOIN pg_catalog.pg_roles r ON (pam.roleid = r.oid)\n"
3864  " LEFT JOIN pg_catalog.pg_roles g ON (pam.grantor = g.oid)\n");
3865 
3866  if (!showSystem && !pattern)
3867  appendPQExpBufferStr(&buf, "WHERE m.rolname !~ '^pg_'\n");
3868 
3869  if (!validateSQLNamePattern(&buf, pattern, false, false,
3870  NULL, "m.rolname", NULL, NULL,
3871  NULL, 1))
3872  {
3873  termPQExpBuffer(&buf);
3874  return false;
3875  }
3876 
3877  appendPQExpBufferStr(&buf, "ORDER BY 1, 2, 4;\n");
3878 
3879  res = PSQLexec(buf.data);
3880  termPQExpBuffer(&buf);
3881  if (!res)
3882  return false;
3883 
3884  myopt.title = _("List of role grants");
3885  myopt.translate_header = true;
3886 
3887  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
3888 
3889  PQclear(res);
3890  return true;
3891 }
3892 
3893 
3894 /*
3895  * listTables()
3896  *
3897  * handler for \dt, \di, etc.
3898  *
3899  * tabtypes is an array of characters, specifying what info is desired:
3900  * t - tables
3901  * i - indexes
3902  * v - views
3903  * m - materialized views
3904  * s - sequences
3905  * E - foreign table (Note: different from 'f', the relkind value)
3906  * (any order of the above is fine)
3907  */
3908 bool
3909 listTables(const char *tabtypes, const char *pattern, bool verbose, bool showSystem)
3910 {
3911  bool showTables = strchr(tabtypes, 't') != NULL;
3912  bool showIndexes = strchr(tabtypes, 'i') != NULL;
3913  bool showViews = strchr(tabtypes, 'v') != NULL;
3914  bool showMatViews = strchr(tabtypes, 'm') != NULL;
3915  bool showSeq = strchr(tabtypes, 's') != NULL;
3916  bool showForeign = strchr(tabtypes, 'E') != NULL;
3917 
3919  PGresult *res;
3920  printQueryOpt myopt = pset.popt;
3921  int cols_so_far;
3922  bool translate_columns[] = {false, false, true, false, false, false, false, false, false};
3923 
3924  /* If tabtypes is empty, we default to \dtvmsE (but see also command.c) */
3925  if (!(showTables || showIndexes || showViews || showMatViews || showSeq || showForeign))
3926  showTables = showViews = showMatViews = showSeq = showForeign = true;
3927 
3928  initPQExpBuffer(&buf);
3929 
3931  "SELECT n.nspname as \"%s\",\n"
3932  " c.relname as \"%s\",\n"
3933  " CASE c.relkind"
3934  " WHEN " CppAsString2(RELKIND_RELATION) " THEN '%s'"
3935  " WHEN " CppAsString2(RELKIND_VIEW) " THEN '%s'"
3936  " WHEN " CppAsString2(RELKIND_MATVIEW) " THEN '%s'"
3937  " WHEN " CppAsString2(RELKIND_INDEX) " THEN '%s'"
3938  " WHEN " CppAsString2(RELKIND_SEQUENCE) " THEN '%s'"
3939  " WHEN " CppAsString2(RELKIND_TOASTVALUE) " THEN '%s'"
3940  " WHEN " CppAsString2(RELKIND_FOREIGN_TABLE) " THEN '%s'"
3941  " WHEN " CppAsString2(RELKIND_PARTITIONED_TABLE) " THEN '%s'"
3942  " WHEN " CppAsString2(RELKIND_PARTITIONED_INDEX) " THEN '%s'"
3943  " END as \"%s\",\n"
3944  " pg_catalog.pg_get_userbyid(c.relowner) as \"%s\"",
3945  gettext_noop("Schema"),
3946  gettext_noop("Name"),
3947  gettext_noop("table"),
3948  gettext_noop("view"),
3949  gettext_noop("materialized view"),
3950  gettext_noop("index"),
3951  gettext_noop("sequence"),
3952  gettext_noop("TOAST table"),
3953  gettext_noop("foreign table"),
3954  gettext_noop("partitioned table"),
3955  gettext_noop("partitioned index"),
3956  gettext_noop("Type"),
3957  gettext_noop("Owner"));
3958  cols_so_far = 4;
3959 
3960  if (showIndexes)
3961  {
3963  ",\n c2.relname as \"%s\"",
3964  gettext_noop("Table"));
3965  cols_so_far++;
3966  }
3967 
3968  if (verbose)
3969  {
3970  /*
3971  * Show whether a relation is permanent, temporary, or unlogged.
3972  */
3974  ",\n CASE c.relpersistence WHEN 'p' THEN '%s' WHEN 't' THEN '%s' WHEN 'u' THEN '%s' END as \"%s\"",
3975  gettext_noop("permanent"),
3976  gettext_noop("temporary"),
3977  gettext_noop("unlogged"),
3978  gettext_noop("Persistence"));
3979  translate_columns[cols_so_far] = true;
3980 
3981  /*
3982  * We don't bother to count cols_so_far below here, as there's no need
3983  * to; this might change with future additions to the output columns.
3984  */
3985 
3986  /*
3987  * Access methods exist for tables, materialized views and indexes.
3988  * This has been introduced in PostgreSQL 12 for tables.
3989  */
3990  if (pset.sversion >= 120000 && !pset.hide_tableam &&
3991  (showTables || showMatViews || showIndexes))
3993  ",\n am.amname as \"%s\"",
3994  gettext_noop("Access method"));
3995 
3997  ",\n pg_catalog.pg_size_pretty(pg_catalog.pg_table_size(c.oid)) as \"%s\""
3998  ",\n pg_catalog.obj_description(c.oid, 'pg_class') as \"%s\"",
3999  gettext_noop("Size"),
4000  gettext_noop("Description"));
4001  }
4002 
4004  "\nFROM pg_catalog.pg_class c"
4005  "\n LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace");
4006 
4007  if (pset.sversion >= 120000 && !pset.hide_tableam &&
4008  (showTables || showMatViews || showIndexes))
4010  "\n LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam");
4011 
4012  if (showIndexes)
4014  "\n LEFT JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid"
4015  "\n LEFT JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid");
4016 
4017  appendPQExpBufferStr(&buf, "\nWHERE c.relkind IN (");
4018  if (showTables)
4019  {
4020  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_RELATION) ","
4021  CppAsString2(RELKIND_PARTITIONED_TABLE) ",");
4022  /* with 'S' or a pattern, allow 't' to match TOAST tables too */
4023  if (showSystem || pattern)
4024  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_TOASTVALUE) ",");
4025  }
4026  if (showViews)
4027  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_VIEW) ",");
4028  if (showMatViews)
4029  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_MATVIEW) ",");
4030  if (showIndexes)
4031  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_INDEX) ","
4032  CppAsString2(RELKIND_PARTITIONED_INDEX) ",");
4033  if (showSeq)
4034  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_SEQUENCE) ",");
4035  if (showSystem || pattern)
4036  appendPQExpBufferStr(&buf, "'s',"); /* was RELKIND_SPECIAL */
4037  if (showForeign)
4038  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_FOREIGN_TABLE) ",");
4039 
4040  appendPQExpBufferStr(&buf, "''"); /* dummy */
4041  appendPQExpBufferStr(&buf, ")\n");
4042 
4043  if (!showSystem && !pattern)
4044  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
4045  " AND n.nspname !~ '^pg_toast'\n"
4046  " AND n.nspname <> 'information_schema'\n");
4047 
4048  if (!validateSQLNamePattern(&buf, pattern, true, false,
4049  "n.nspname", "c.relname", NULL,
4050  "pg_catalog.pg_table_is_visible(c.oid)",
4051  NULL, 3))
4052  {
4053  termPQExpBuffer(&buf);
4054  return false;
4055  }
4056 
4057  appendPQExpBufferStr(&buf, "ORDER BY 1,2;");
4058 
4059  res = PSQLexec(buf.data);
4060  termPQExpBuffer(&buf);
4061  if (!res)
4062  return false;
4063 
4064  /*
4065  * Most functions in this file are content to print an empty table when
4066  * there are no matching objects. We intentionally deviate from that
4067  * here, but only in !quiet mode, for historical reasons.
4068  */
4069  if (PQntuples(res) == 0 && !pset.quiet)
4070  {
4071  if (pattern)
4072  pg_log_error("Did not find any relation named \"%s\".",
4073  pattern);
4074  else
4075  pg_log_error("Did not find any relations.");
4076  }
4077  else
4078  {
4079  myopt.title = _("List of relations");
4080  myopt.translate_header = true;
4081  myopt.translate_columns = translate_columns;
4082  myopt.n_translate_columns = lengthof(translate_columns);
4083 
4084  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4085  }
4086 
4087  PQclear(res);
4088  return true;
4089 }
4090 
4091 /*
4092  * \dP
4093  * Takes an optional regexp to select particular relations
4094  *
4095  * As with \d, you can specify the kinds of relations you want:
4096  *
4097  * t for tables
4098  * i for indexes
4099  *
4100  * And there's additional flags:
4101  *
4102  * n to list non-leaf partitioned tables
4103  *
4104  * and you can mix and match these in any order.
4105  */
4106 bool
4107 listPartitionedTables(const char *reltypes, const char *pattern, bool verbose)
4108 {
4109  bool showTables = strchr(reltypes, 't') != NULL;
4110  bool showIndexes = strchr(reltypes, 'i') != NULL;
4111  bool showNested = strchr(reltypes, 'n') != NULL;
4113  PQExpBufferData title;
4114  PGresult *res;
4115  printQueryOpt myopt = pset.popt;
4116  bool translate_columns[] = {false, false, false, false, false, false, false, false, false};
4117  const char *tabletitle;
4118  bool mixed_output = false;
4119 
4120  /*
4121  * Note: Declarative table partitioning is only supported as of Pg 10.0.
4122  */
4123  if (pset.sversion < 100000)
4124  {
4125  char sverbuf[32];
4126 
4127  pg_log_error("The server (version %s) does not support declarative table partitioning.",
4129  sverbuf, sizeof(sverbuf)));
4130  return true;
4131  }
4132 
4133  /* If no relation kind was selected, show them all */
4134  if (!showTables && !showIndexes)
4135  showTables = showIndexes = true;
4136 
4137  if (showIndexes && !showTables)
4138  tabletitle = _("List of partitioned indexes"); /* \dPi */
4139  else if (showTables && !showIndexes)
4140  tabletitle = _("List of partitioned tables"); /* \dPt */
4141  else
4142  {
4143  /* show all kinds */
4144  tabletitle = _("List of partitioned relations");
4145  mixed_output = true;
4146  }
4147 
4148  initPQExpBuffer(&buf);
4149 
4151  "SELECT n.nspname as \"%s\",\n"
4152  " c.relname as \"%s\",\n"
4153  " pg_catalog.pg_get_userbyid(c.relowner) as \"%s\"",
4154  gettext_noop("Schema"),
4155  gettext_noop("Name"),
4156  gettext_noop("Owner"));
4157 
4158  if (mixed_output)
4159  {
4161  ",\n CASE c.relkind"
4162  " WHEN " CppAsString2(RELKIND_PARTITIONED_TABLE) " THEN '%s'"
4163  " WHEN " CppAsString2(RELKIND_PARTITIONED_INDEX) " THEN '%s'"
4164  " END as \"%s\"",
4165  gettext_noop("partitioned table"),
4166  gettext_noop("partitioned index"),
4167  gettext_noop("Type"));
4168 
4169  translate_columns[3] = true;
4170  }
4171 
4172  if (showNested || pattern)
4174  ",\n inh.inhparent::pg_catalog.regclass as \"%s\"",
4175  gettext_noop("Parent name"));
4176 
4177  if (showIndexes)
4179  ",\n c2.oid::pg_catalog.regclass as \"%s\"",
4180  gettext_noop("Table"));
4181 
4182  if (verbose)
4183  {
4184  if (showNested)
4185  {
4187  ",\n s.dps as \"%s\"",
4188  gettext_noop("Leaf partition size"));
4190  ",\n s.tps as \"%s\"",
4191  gettext_noop("Total size"));
4192  }
4193  else
4194  /* Sizes of all partitions are considered in this case. */
4196  ",\n s.tps as \"%s\"",
4197  gettext_noop("Total size"));
4198 
4200  ",\n pg_catalog.obj_description(c.oid, 'pg_class') as \"%s\"",
4201  gettext_noop("Description"));
4202  }
4203 
4205  "\nFROM pg_catalog.pg_class c"
4206  "\n LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace");
4207 
4208  if (showIndexes)
4210  "\n LEFT JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid"
4211  "\n LEFT JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid");
4212 
4213  if (showNested || pattern)
4215  "\n LEFT JOIN pg_catalog.pg_inherits inh ON c.oid = inh.inhrelid");
4216 
4217  if (verbose)
4218  {
4219  if (pset.sversion < 120000)
4220  {
4222  ",\n LATERAL (WITH RECURSIVE d\n"
4223  " AS (SELECT inhrelid AS oid, 1 AS level\n"
4224  " FROM pg_catalog.pg_inherits\n"
4225  " WHERE inhparent = c.oid\n"
4226  " UNION ALL\n"
4227  " SELECT inhrelid, level + 1\n"
4228  " FROM pg_catalog.pg_inherits i\n"
4229  " JOIN d ON i.inhparent = d.oid)\n"
4230  " SELECT pg_catalog.pg_size_pretty(sum(pg_catalog.pg_table_size("
4231  "d.oid))) AS tps,\n"
4232  " pg_catalog.pg_size_pretty(sum("
4233  "\n CASE WHEN d.level = 1"
4234  " THEN pg_catalog.pg_table_size(d.oid) ELSE 0 END)) AS dps\n"
4235  " FROM d) s");
4236  }
4237  else
4238  {
4239  /* PostgreSQL 12 has pg_partition_tree function */
4241  ",\n LATERAL (SELECT pg_catalog.pg_size_pretty(sum("
4242  "\n CASE WHEN ppt.isleaf AND ppt.level = 1"
4243  "\n THEN pg_catalog.pg_table_size(ppt.relid)"
4244  " ELSE 0 END)) AS dps"
4245  ",\n pg_catalog.pg_size_pretty(sum("
4246  "pg_catalog.pg_table_size(ppt.relid))) AS tps"
4247  "\n FROM pg_catalog.pg_partition_tree(c.oid) ppt) s");
4248  }
4249  }
4250 
4251  appendPQExpBufferStr(&buf, "\nWHERE c.relkind IN (");
4252  if (showTables)
4253  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_PARTITIONED_TABLE) ",");
4254  if (showIndexes)
4255  appendPQExpBufferStr(&buf, CppAsString2(RELKIND_PARTITIONED_INDEX) ",");
4256  appendPQExpBufferStr(&buf, "''"); /* dummy */
4257  appendPQExpBufferStr(&buf, ")\n");
4258 
4259  appendPQExpBufferStr(&buf, !showNested && !pattern ?
4260  " AND NOT c.relispartition\n" : "");
4261 
4262  if (!pattern)
4263  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
4264  " AND n.nspname !~ '^pg_toast'\n"
4265  " AND n.nspname <> 'information_schema'\n");
4266 
4267  if (!validateSQLNamePattern(&buf, pattern, true, false,
4268  "n.nspname", "c.relname", NULL,
4269  "pg_catalog.pg_table_is_visible(c.oid)",
4270  NULL, 3))
4271  {
4272  termPQExpBuffer(&buf);
4273  return false;
4274  }
4275 
4276  appendPQExpBuffer(&buf, "ORDER BY \"Schema\", %s%s\"Name\";",
4277  mixed_output ? "\"Type\" DESC, " : "",
4278  showNested || pattern ? "\"Parent name\" NULLS FIRST, " : "");
4279 
4280  res = PSQLexec(buf.data);
4281  termPQExpBuffer(&buf);
4282  if (!res)
4283  return false;
4284 
4285  initPQExpBuffer(&title);
4286  appendPQExpBufferStr(&title, tabletitle);
4287 
4288  myopt.title = title.data;
4289  myopt.translate_header = true;
4290  myopt.translate_columns = translate_columns;
4291  myopt.n_translate_columns = lengthof(translate_columns);
4292 
4293  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4294 
4295  termPQExpBuffer(&title);
4296 
4297  PQclear(res);
4298  return true;
4299 }
4300 
4301 /*
4302  * \dL
4303  *
4304  * Describes languages.
4305  */
4306 bool
4307 listLanguages(const char *pattern, bool verbose, bool showSystem)
4308 {
4310  PGresult *res;
4311  printQueryOpt myopt = pset.popt;
4312 
4313  initPQExpBuffer(&buf);
4314 
4316  "SELECT l.lanname AS \"%s\",\n"
4317  " pg_catalog.pg_get_userbyid(l.lanowner) as \"%s\",\n"
4318  " l.lanpltrusted AS \"%s\"",
4319  gettext_noop("Name"),
4320  gettext_noop("Owner"),
4321  gettext_noop("Trusted"));
4322 
4323  if (verbose)
4324  {
4326  ",\n NOT l.lanispl AS \"%s\",\n"
4327  " l.lanplcallfoid::pg_catalog.regprocedure AS \"%s\",\n"
4328  " l.lanvalidator::pg_catalog.regprocedure AS \"%s\",\n "
4329  "l.laninline::pg_catalog.regprocedure AS \"%s\",\n ",
4330  gettext_noop("Internal language"),
4331  gettext_noop("Call handler"),
4332  gettext_noop("Validator"),
4333  gettext_noop("Inline handler"));
4334  printACLColumn(&buf, "l.lanacl");
4335  }
4336 
4338  ",\n d.description AS \"%s\""
4339  "\nFROM pg_catalog.pg_language l\n"
4340  "LEFT JOIN pg_catalog.pg_description d\n"
4341  " ON d.classoid = l.tableoid AND d.objoid = l.oid\n"
4342  " AND d.objsubid = 0\n",
4343  gettext_noop("Description"));
4344 
4345  if (pattern)
4346  {
4347  if (!validateSQLNamePattern(&buf, pattern, false, false,
4348  NULL, "l.lanname", NULL, NULL,
4349  NULL, 2))
4350  {
4351  termPQExpBuffer(&buf);
4352  return false;
4353  }
4354  }
4355 
4356  if (!showSystem && !pattern)
4357  appendPQExpBufferStr(&buf, "WHERE l.lanplcallfoid != 0\n");
4358 
4359 
4360  appendPQExpBufferStr(&buf, "ORDER BY 1;");
4361 
4362  res = PSQLexec(buf.data);
4363  termPQExpBuffer(&buf);
4364  if (!res)
4365  return false;
4366 
4367  myopt.title = _("List of languages");
4368  myopt.translate_header = true;
4369 
4370  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4371 
4372  PQclear(res);
4373  return true;
4374 }
4375 
4376 
4377 /*
4378  * \dD
4379  *
4380  * Describes domains.
4381  */
4382 bool
4383 listDomains(const char *pattern, bool verbose, bool showSystem)
4384 {
4386  PGresult *res;
4387  printQueryOpt myopt = pset.popt;
4388 
4389  initPQExpBuffer(&buf);
4390 
4392  "SELECT n.nspname as \"%s\",\n"
4393  " t.typname as \"%s\",\n"
4394  " pg_catalog.format_type(t.typbasetype, t.typtypmod) as \"%s\",\n"
4395  " (SELECT c.collname FROM pg_catalog.pg_collation c, pg_catalog.pg_type bt\n"
4396  " WHERE c.oid = t.typcollation AND bt.oid = t.typbasetype AND t.typcollation <> bt.typcollation) as \"%s\",\n"
4397  " CASE WHEN t.typnotnull THEN 'not null' END as \"%s\",\n"
4398  " t.typdefault as \"%s\",\n"
4399  " pg_catalog.array_to_string(ARRAY(\n"
4400  " SELECT pg_catalog.pg_get_constraintdef(r.oid, true) FROM pg_catalog.pg_constraint r WHERE t.oid = r.contypid AND r.contype = 'c' ORDER BY r.conname\n"
4401  " ), ' ') as \"%s\"",
4402  gettext_noop("Schema"),
4403  gettext_noop("Name"),
4404  gettext_noop("Type"),
4405  gettext_noop("Collation"),
4406  gettext_noop("Nullable"),
4407  gettext_noop("Default"),
4408  gettext_noop("Check"));
4409 
4410  if (verbose)
4411  {
4412  appendPQExpBufferStr(&buf, ",\n ");
4413  printACLColumn(&buf, "t.typacl");
4415  ",\n d.description as \"%s\"",
4416  gettext_noop("Description"));
4417  }
4418 
4420  "\nFROM pg_catalog.pg_type t\n"
4421  " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n");
4422 
4423  if (verbose)
4425  " LEFT JOIN pg_catalog.pg_description d "
4426  "ON d.classoid = t.tableoid AND d.objoid = t.oid "
4427  "AND d.objsubid = 0\n");
4428 
4429  appendPQExpBufferStr(&buf, "WHERE t.typtype = 'd'\n");
4430 
4431  if (!showSystem && !pattern)
4432  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
4433  " AND n.nspname <> 'information_schema'\n");
4434 
4435  if (!validateSQLNamePattern(&buf, pattern, true, false,
4436  "n.nspname", "t.typname", NULL,
4437  "pg_catalog.pg_type_is_visible(t.oid)",
4438  NULL, 3))
4439  {
4440  termPQExpBuffer(&buf);
4441  return false;
4442  }
4443 
4444  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
4445 
4446  res = PSQLexec(buf.data);
4447  termPQExpBuffer(&buf);
4448  if (!res)
4449  return false;
4450 
4451  myopt.title = _("List of domains");
4452  myopt.translate_header = true;
4453 
4454  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4455 
4456  PQclear(res);
4457  return true;
4458 }
4459 
4460 /*
4461  * \dc
4462  *
4463  * Describes conversions.
4464  */
4465 bool
4466 listConversions(const char *pattern, bool verbose, bool showSystem)
4467 {
4469  PGresult *res;
4470  printQueryOpt myopt = pset.popt;
4471  static const bool translate_columns[] =
4472  {false, false, false, false, true, false};
4473 
4474  initPQExpBuffer(&buf);
4475 
4477  "SELECT n.nspname AS \"%s\",\n"
4478  " c.conname AS \"%s\",\n"
4479  " pg_catalog.pg_encoding_to_char(c.conforencoding) AS \"%s\",\n"
4480  " pg_catalog.pg_encoding_to_char(c.contoencoding) AS \"%s\",\n"
4481  " CASE WHEN c.condefault THEN '%s'\n"
4482  " ELSE '%s' END AS \"%s\"",
4483  gettext_noop("Schema"),
4484  gettext_noop("Name"),
4485  gettext_noop("Source"),
4486  gettext_noop("Destination"),
4487  gettext_noop("yes"), gettext_noop("no"),
4488  gettext_noop("Default?"));
4489 
4490  if (verbose)
4492  ",\n d.description AS \"%s\"",
4493  gettext_noop("Description"));
4494 
4496  "\nFROM pg_catalog.pg_conversion c\n"
4497  " JOIN pg_catalog.pg_namespace n "
4498  "ON n.oid = c.connamespace\n");
4499 
4500  if (verbose)
4502  "LEFT JOIN pg_catalog.pg_description d "
4503  "ON d.classoid = c.tableoid\n"
4504  " AND d.objoid = c.oid "
4505  "AND d.objsubid = 0\n");
4506 
4507  appendPQExpBufferStr(&buf, "WHERE true\n");
4508 
4509  if (!showSystem && !pattern)
4510  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
4511  " AND n.nspname <> 'information_schema'\n");
4512 
4513  if (!validateSQLNamePattern(&buf, pattern, true, false,
4514  "n.nspname", "c.conname", NULL,
4515  "pg_catalog.pg_conversion_is_visible(c.oid)",
4516  NULL, 3))
4517  {
4518  termPQExpBuffer(&buf);
4519  return false;
4520  }
4521 
4522  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
4523 
4524  res = PSQLexec(buf.data);
4525  termPQExpBuffer(&buf);
4526  if (!res)
4527  return false;
4528 
4529  myopt.title = _("List of conversions");
4530  myopt.translate_header = true;
4531  myopt.translate_columns = translate_columns;
4532  myopt.n_translate_columns = lengthof(translate_columns);
4533 
4534  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4535 
4536  PQclear(res);
4537  return true;
4538 }
4539 
4540 /*
4541  * \dconfig
4542  *
4543  * Describes configuration parameters.
4544  */
4545 bool
4546 describeConfigurationParameters(const char *pattern, bool verbose,
4547  bool showSystem)
4548 {
4550  PGresult *res;
4551  printQueryOpt myopt = pset.popt;
4552 
4553  initPQExpBuffer(&buf);
4555  "SELECT s.name AS \"%s\", "
4556  "pg_catalog.current_setting(s.name) AS \"%s\"",
4557  gettext_noop("Parameter"),
4558  gettext_noop("Value"));
4559 
4560  if (verbose)
4561  {
4563  ", s.vartype AS \"%s\", s.context AS \"%s\", ",
4564  gettext_noop("Type"),
4565  gettext_noop("Context"));
4566  if (pset.sversion >= 150000)
4567  printACLColumn(&buf, "p.paracl");
4568  else
4569  appendPQExpBuffer(&buf, "NULL AS \"%s\"",
4570  gettext_noop("Access privileges"));
4571  }
4572 
4573  appendPQExpBufferStr(&buf, "\nFROM pg_catalog.pg_settings s\n");
4574 
4575  if (verbose && pset.sversion >= 150000)
4577  " LEFT JOIN pg_catalog.pg_parameter_acl p\n"
4578  " ON pg_catalog.lower(s.name) = p.parname\n");
4579 
4580  if (pattern)
4581  processSQLNamePattern(pset.db, &buf, pattern,
4582  false, false,
4583  NULL, "pg_catalog.lower(s.name)", NULL,
4584  NULL, NULL, NULL);
4585  else
4586  appendPQExpBufferStr(&buf, "WHERE s.source <> 'default' AND\n"
4587  " s.setting IS DISTINCT FROM s.boot_val\n");
4588 
4589  appendPQExpBufferStr(&buf, "ORDER BY 1;");
4590 
4591  res = PSQLexec(buf.data);
4592  termPQExpBuffer(&buf);
4593  if (!res)
4594  return false;
4595 
4596  if (pattern)
4597  myopt.title = _("List of configuration parameters");
4598  else
4599  myopt.title = _("List of non-default configuration parameters");
4600  myopt.translate_header = true;
4601 
4602  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4603 
4604  PQclear(res);
4605  return true;
4606 }
4607 
4608 /*
4609  * \dy
4610  *
4611  * Describes Event Triggers.
4612  */
4613 bool
4614 listEventTriggers(const char *pattern, bool verbose)
4615 {
4617  PGresult *res;
4618  printQueryOpt myopt = pset.popt;
4619  static const bool translate_columns[] =
4620  {false, false, false, true, false, false, false};
4621 
4622  if (pset.sversion < 90300)
4623  {
4624  char sverbuf[32];
4625 
4626  pg_log_error("The server (version %s) does not support event triggers.",
4628  sverbuf, sizeof(sverbuf)));
4629  return true;
4630  }
4631 
4632  initPQExpBuffer(&buf);
4633 
4635  "SELECT evtname as \"%s\", "
4636  "evtevent as \"%s\", "
4637  "pg_catalog.pg_get_userbyid(e.evtowner) as \"%s\",\n"
4638  " case evtenabled when 'O' then '%s'"
4639  " when 'R' then '%s'"
4640  " when 'A' then '%s'"
4641  " when 'D' then '%s' end as \"%s\",\n"
4642  " e.evtfoid::pg_catalog.regproc as \"%s\", "
4643  "pg_catalog.array_to_string(array(select x"
4644  " from pg_catalog.unnest(evttags) as t(x)), ', ') as \"%s\"",
4645  gettext_noop("Name"),
4646  gettext_noop("Event"),
4647  gettext_noop("Owner"),
4648  gettext_noop("enabled"),
4649  gettext_noop("replica"),
4650  gettext_noop("always"),
4651  gettext_noop("disabled"),
4652  gettext_noop("Enabled"),
4653  gettext_noop("Function"),
4654  gettext_noop("Tags"));
4655  if (verbose)
4657  ",\npg_catalog.obj_description(e.oid, 'pg_event_trigger') as \"%s\"",
4658  gettext_noop("Description"));
4660  "\nFROM pg_catalog.pg_event_trigger e ");
4661 
4662  if (!validateSQLNamePattern(&buf, pattern, false, false,
4663  NULL, "evtname", NULL, NULL,
4664  NULL, 1))
4665  {
4666  termPQExpBuffer(&buf);
4667  return false;
4668  }
4669 
4670  appendPQExpBufferStr(&buf, "ORDER BY 1");
4671 
4672  res = PSQLexec(buf.data);
4673  termPQExpBuffer(&buf);
4674  if (!res)
4675  return false;
4676 
4677  myopt.title = _("List of event triggers");
4678  myopt.translate_header = true;
4679  myopt.translate_columns = translate_columns;
4680  myopt.n_translate_columns = lengthof(translate_columns);
4681 
4682  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4683 
4684  PQclear(res);
4685  return true;
4686 }
4687 
4688 /*
4689  * \dX
4690  *
4691  * Describes extended statistics.
4692  */
4693 bool
4694 listExtendedStats(const char *pattern)
4695 {
4697  PGresult *res;
4698  printQueryOpt myopt = pset.popt;
4699 
4700  if (pset.sversion < 100000)
4701  {
4702  char sverbuf[32];
4703 
4704  pg_log_error("The server (version %s) does not support extended statistics.",
4706  sverbuf, sizeof(sverbuf)));
4707  return true;
4708  }
4709 
4710  initPQExpBuffer(&buf);
4712  "SELECT \n"
4713  "es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text AS \"%s\", \n"
4714  "es.stxname AS \"%s\", \n",
4715  gettext_noop("Schema"),
4716  gettext_noop("Name"));
4717 
4718  if (pset.sversion >= 140000)
4720  "pg_catalog.format('%%s FROM %%s', \n"
4721  " pg_catalog.pg_get_statisticsobjdef_columns(es.oid), \n"
4722  " es.stxrelid::pg_catalog.regclass) AS \"%s\"",
4723  gettext_noop("Definition"));
4724  else
4726  "pg_catalog.format('%%s FROM %%s', \n"
4727  " (SELECT pg_catalog.string_agg(pg_catalog.quote_ident(a.attname),', ') \n"
4728  " FROM pg_catalog.unnest(es.stxkeys) s(attnum) \n"
4729  " JOIN pg_catalog.pg_attribute a \n"
4730  " ON (es.stxrelid = a.attrelid \n"
4731  " AND a.attnum = s.attnum \n"
4732  " AND NOT a.attisdropped)), \n"
4733  "es.stxrelid::pg_catalog.regclass) AS \"%s\"",
4734  gettext_noop("Definition"));
4735 
4737  ",\nCASE WHEN 'd' = any(es.stxkind) THEN 'defined' \n"
4738  "END AS \"%s\", \n"
4739  "CASE WHEN 'f' = any(es.stxkind) THEN 'defined' \n"
4740  "END AS \"%s\"",
4741  gettext_noop("Ndistinct"),
4742  gettext_noop("Dependencies"));
4743 
4744  /*
4745  * Include the MCV statistics kind.
4746  */
4747  if (pset.sversion >= 120000)
4748  {
4750  ",\nCASE WHEN 'm' = any(es.stxkind) THEN 'defined' \n"
4751  "END AS \"%s\" ",
4752  gettext_noop("MCV"));
4753  }
4754 
4756  " \nFROM pg_catalog.pg_statistic_ext es \n");
4757 
4758  if (!validateSQLNamePattern(&buf, pattern,
4759  false, false,
4760  "es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text", "es.stxname",
4761  NULL, "pg_catalog.pg_statistics_obj_is_visible(es.oid)",
4762  NULL, 3))
4763  {
4764  termPQExpBuffer(&buf);
4765  return false;
4766  }
4767 
4768  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
4769 
4770  res = PSQLexec(buf.data);
4771  termPQExpBuffer(&buf);
4772  if (!res)
4773  return false;
4774 
4775  myopt.title = _("List of extended statistics");
4776  myopt.translate_header = true;
4777 
4778  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4779 
4780  PQclear(res);
4781  return true;
4782 }
4783 
4784 /*
4785  * \dC
4786  *
4787  * Describes casts.
4788  */
4789 bool
4790 listCasts(const char *pattern, bool verbose)
4791 {
4793  PGresult *res;
4794  printQueryOpt myopt = pset.popt;
4795  static const bool translate_columns[] = {false, false, false, true, false};
4796 
4797  initPQExpBuffer(&buf);
4798 
4800  "SELECT pg_catalog.format_type(castsource, NULL) AS \"%s\",\n"
4801  " pg_catalog.format_type(casttarget, NULL) AS \"%s\",\n",
4802  gettext_noop("Source type"),
4803  gettext_noop("Target type"));
4804 
4805  /*
4806  * We don't attempt to localize '(binary coercible)' or '(with inout)',
4807  * because there's too much risk of gettext translating a function name
4808  * that happens to match some string in the PO database.
4809  */
4811  " CASE WHEN c.castmethod = '%c' THEN '(binary coercible)'\n"
4812  " WHEN c.castmethod = '%c' THEN '(with inout)'\n"
4813  " ELSE p.proname\n"
4814  " END AS \"%s\",\n",
4815  COERCION_METHOD_BINARY,
4816  COERCION_METHOD_INOUT,
4817  gettext_noop("Function"));
4818 
4820  " CASE WHEN c.castcontext = '%c' THEN '%s'\n"
4821  " WHEN c.castcontext = '%c' THEN '%s'\n"
4822  " ELSE '%s'\n"
4823  " END AS \"%s\"",
4824  COERCION_CODE_EXPLICIT,
4825  gettext_noop("no"),
4826  COERCION_CODE_ASSIGNMENT,
4827  gettext_noop("in assignment"),
4828  gettext_noop("yes"),
4829  gettext_noop("Implicit?"));
4830 
4831  if (verbose)
4833  ",\n d.description AS \"%s\"",
4834  gettext_noop("Description"));
4835 
4836  /*
4837  * We need a left join to pg_proc for binary casts; the others are just
4838  * paranoia.
4839  */
4841  "\nFROM pg_catalog.pg_cast c LEFT JOIN pg_catalog.pg_proc p\n"
4842  " ON c.castfunc = p.oid\n"
4843  " LEFT JOIN pg_catalog.pg_type ts\n"
4844  " ON c.castsource = ts.oid\n"
4845  " LEFT JOIN pg_catalog.pg_namespace ns\n"
4846  " ON ns.oid = ts.typnamespace\n"
4847  " LEFT JOIN pg_catalog.pg_type tt\n"
4848  " ON c.casttarget = tt.oid\n"
4849  " LEFT JOIN pg_catalog.pg_namespace nt\n"
4850  " ON nt.oid = tt.typnamespace\n");
4851 
4852  if (verbose)
4854  " LEFT JOIN pg_catalog.pg_description d\n"
4855  " ON d.classoid = c.tableoid AND d.objoid = "
4856  "c.oid AND d.objsubid = 0\n");
4857 
4858  appendPQExpBufferStr(&buf, "WHERE ( (true");
4859 
4860  /*
4861  * Match name pattern against either internal or external name of either
4862  * castsource or casttarget
4863  */
4864  if (!validateSQLNamePattern(&buf, pattern, true, false,
4865  "ns.nspname", "ts.typname",
4866  "pg_catalog.format_type(ts.oid, NULL)",
4867  "pg_catalog.pg_type_is_visible(ts.oid)",
4868  NULL, 3))
4869  goto error_return;
4870 
4871  appendPQExpBufferStr(&buf, ") OR (true");
4872 
4873  if (!validateSQLNamePattern(&buf, pattern, true, false,
4874  "nt.nspname", "tt.typname",
4875  "pg_catalog.format_type(tt.oid, NULL)",
4876  "pg_catalog.pg_type_is_visible(tt.oid)",
4877  NULL, 3))
4878  goto error_return;
4879 
4880  appendPQExpBufferStr(&buf, ") )\nORDER BY 1, 2;");
4881 
4882  res = PSQLexec(buf.data);
4883  termPQExpBuffer(&buf);
4884  if (!res)
4885  return false;
4886 
4887  myopt.title = _("List of casts");
4888  myopt.translate_header = true;
4889  myopt.translate_columns = translate_columns;
4890  myopt.n_translate_columns = lengthof(translate_columns);
4891 
4892  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
4893 
4894  PQclear(res);
4895  return true;
4896 
4897 error_return:
4898  termPQExpBuffer(&buf);
4899  return false;
4900 }
4901 
4902 /*
4903  * \dO
4904  *
4905  * Describes collations.
4906  */
4907 bool
4908 listCollations(const char *pattern, bool verbose, bool showSystem)
4909 {
4911  PGresult *res;
4912  printQueryOpt myopt = pset.popt;
4913  static const bool translate_columns[] = {false, false, false, false, false, false, false, true, false};
4914 
4915  initPQExpBuffer(&buf);
4916 
4918  "SELECT\n"
4919  " n.nspname AS \"%s\",\n"
4920  " c.collname AS \"%s\",\n",
4921  gettext_noop("Schema"),
4922  gettext_noop("Name"));
4923 
4924  if (pset.sversion >= 100000)
4926  " CASE c.collprovider WHEN 'd' THEN 'default' WHEN 'b' THEN 'builtin' WHEN 'c' THEN 'libc' WHEN 'i' THEN 'icu' END AS \"%s\",\n",
4927  gettext_noop("Provider"));
4928  else
4930  " 'libc' AS \"%s\",\n",
4931  gettext_noop("Provider"));
4932 
4934  " c.collcollate AS \"%s\",\n"
4935  " c.collctype AS \"%s\",\n",
4936  gettext_noop("Collate"),
4937  gettext_noop("Ctype"));
4938 
4939  if (pset.sversion >= 170000)
4941  " c.colllocale AS \"%s\",\n",
4942  gettext_noop("Locale"));
4943  else if (pset.sversion >= 150000)
4945  " c.colliculocale AS \"%s\",\n",
4946  gettext_noop("Locale"));
4947  else
4949  " c.collcollate AS \"%s\",\n",
4950  gettext_noop("Locale"));
4951 
4952  if (pset.sversion >= 160000)
4954  " c.collicurules AS \"%s\",\n",
4955  gettext_noop("ICU Rules"));
4956  else
4958  " NULL AS \"%s\",\n",
4959  gettext_noop("ICU Rules"));
4960 
4961  if (pset.sversion >= 120000)
4963  " CASE WHEN c.collisdeterministic THEN '%s' ELSE '%s' END AS \"%s\"",
4964  gettext_noop("yes"), gettext_noop("no"),
4965  gettext_noop("Deterministic?"));
4966  else
4968  " '%s' AS \"%s\"",
4969  gettext_noop("yes"),
4970  gettext_noop("Deterministic?"));
4971 
4972  if (verbose)
4974  ",\n pg_catalog.obj_description(c.oid, 'pg_collation') AS \"%s\"",
4975  gettext_noop("Description"));
4976 
4978  "\nFROM pg_catalog.pg_collation c, pg_catalog.pg_namespace n\n"
4979  "WHERE n.oid = c.collnamespace\n");
4980 
4981  if (!showSystem && !pattern)
4982  appendPQExpBufferStr(&buf, " AND n.nspname <> 'pg_catalog'\n"
4983  " AND n.nspname <> 'information_schema'\n");
4984 
4985  /*
4986  * Hide collations that aren't usable in the current database's encoding.
4987  * If you think to change this, note that pg_collation_is_visible rejects
4988  * unusable collations, so you will need to hack name pattern processing
4989  * somehow to avoid inconsistent behavior.
4990  */
4991  appendPQExpBufferStr(&buf, " AND c.collencoding IN (-1, pg_catalog.pg_char_to_encoding(pg_catalog.getdatabaseencoding()))\n");
4992 
4993  if (!validateSQLNamePattern(&buf, pattern, true, false,
4994  "n.nspname", "c.collname", NULL,
4995  "pg_catalog.pg_collation_is_visible(c.oid)",
4996  NULL, 3))
4997  {
4998  termPQExpBuffer(&buf);
4999  return false;
5000  }
5001 
5002  appendPQExpBufferStr(&buf, "ORDER BY 1, 2;");
5003 
5004  res = PSQLexec(buf.data);
5005  termPQExpBuffer(&buf);
5006  if (!res)
5007  return false;
5008 
5009  myopt.title = _("List of collations");
5010  myopt.translate_header = true;
5011  myopt.translate_columns = translate_columns;
5012  myopt.n_translate_columns = lengthof(translate_columns);
5013 
5014  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
5015 
5016  PQclear(res);
5017  return true;
5018 }
5019 
5020 /*
5021  * \dn
5022  *
5023  * Describes schemas (namespaces)
5024  */
5025 bool
5026 listSchemas(const char *pattern, bool verbose, bool showSystem)
5027 {
5029  PGresult *res;
5030  printQueryOpt myopt = pset.popt;
5031  int pub_schema_tuples = 0;
5032  char **footers = NULL;
5033 
5034  initPQExpBuffer(&buf);
5036  "SELECT n.nspname AS \"%s\",\n"
5037  " pg_catalog.pg_get_userbyid(n.nspowner) AS \"%s\"",
5038  gettext_noop("Name"),
5039  gettext_noop("Owner"));
5040 
5041  if (verbose)
5042  {
5043  appendPQExpBufferStr(&buf, ",\n ");
5044  printACLColumn(&buf, "n.nspacl");
5046  ",\n pg_catalog.obj_description(n.oid, 'pg_namespace') AS \"%s\"",
5047  gettext_noop("Description"));
5048  }
5049 
5051  "\nFROM pg_catalog.pg_namespace n\n");
5052 
5053  if (!showSystem && !pattern)
5055  "WHERE n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'\n");
5056 
5057  if (!validateSQLNamePattern(&buf, pattern,
5058  !showSystem && !pattern, false,
5059  NULL, "n.nspname", NULL,
5060  NULL,
5061  NULL, 2))
5062  goto error_return;
5063 
5064  appendPQExpBufferStr(&buf, "ORDER BY 1;");
5065 
5066  res = PSQLexec(buf.data);
5067  if (!res)
5068  goto error_return;
5069 
5070  myopt.title = _("List of schemas");
5071  myopt.translate_header = true;
5072 
5073  if (pattern && pset.sversion >= 150000)
5074  {
5075  PGresult *result;
5076  int i;
5077 
5079  "SELECT pubname \n"
5080  "FROM pg_catalog.pg_publication p\n"
5081  " JOIN pg_catalog.pg_publication_namespace pn ON p.oid = pn.pnpubid\n"
5082  " JOIN pg_catalog.pg_namespace n ON n.oid = pn.pnnspid \n"
5083  "WHERE n.nspname = '%s'\n"
5084  "ORDER BY 1",
5085  pattern);
5086  result = PSQLexec(buf.data);
5087  if (!result)
5088  goto error_return;
5089  else
5090  pub_schema_tuples = PQntuples(result);
5091 
5092  if (pub_schema_tuples > 0)
5093  {
5094  /*
5095  * Allocate memory for footers. Size of footers will be 1 (for
5096  * storing "Publications:" string) + publication schema mapping
5097  * count + 1 (for storing NULL).
5098  */
5099  footers = (char **) pg_malloc((1 + pub_schema_tuples + 1) * sizeof(char *));
5100  footers[0] = pg_strdup(_("Publications:"));
5101 
5102  /* Might be an empty set - that's ok */
5103  for (i = 0; i < pub_schema_tuples; i++)
5104  {
5105  printfPQExpBuffer(&buf, " \"%s\"",
5106  PQgetvalue(result, i, 0));
5107 
5108  footers[i + 1] = pg_strdup(buf.data);
5109  }
5110 
5111  footers[i + 1] = NULL;
5112  myopt.footers = footers;
5113  }
5114 
5115  PQclear(result);
5116  }
5117 
5118  printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
5119 
5120  termPQExpBuffer(&buf);
5121  PQclear(res);
5122 
5123  /* Free the memory allocated for the footer */
5124  if (footers)
5125  {
5126  char **footer = NULL;
5127 
5128  for (footer = footers; *footer; footer++)
5129  pg_free(*footer);
5130 
5131  pg_free(footers);
5132  }
5133 
5134  return true;
5135 
5136 error_return:
5137  termPQExpBuffer(&buf);
5138  return false;
5139 }
5140 
5141 
5142 /*
5143  * \dFp
5144  * list text search parsers
5145  */
5146 bool
5147 listTSParsers(const char *pattern, bool verbose)
5148 {
5150  PGresult *res;
5151  printQueryOpt myopt = pset.popt;
5152 
5153  if (verbose)
5154  return listTSParsersVerbose(pattern);
5155 
5156  initPQExpBuffer(&buf);
5157 
5159  "SELECT\n"
5160  " n.nspname as \"%s\",\n"
5161  " p.prsname as \"%s\",\n"
5162  " pg_catalog.obj_description(p.oid, 'pg_ts_parser') as \"%s\"\n"
5163  "FROM pg_catalog.pg_ts_parser p\n"
5164  "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.prsnamespace\n",
5165  gettext_noop("Schema"),
5166  gettext_noop("Name"),
5167  gettext_noop("Description")
5168  );
5169