PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
pg_dumpall.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * pg_dumpall.c
4 *
5 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
6 * Portions Copyright (c) 1994, Regents of the University of California
7 *
8 * pg_dumpall forces all pg_dump output to be text, since it also outputs
9 * text into the same output stream.
10 *
11 * src/bin/pg_dump/pg_dumpall.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16#include "postgres_fe.h"
17
18#include <time.h>
19#include <unistd.h>
20
21#include "catalog/pg_authid_d.h"
22#include "common/connect.h"
23#include "common/file_utils.h"
25#include "common/logging.h"
26#include "common/string.h"
27#include "dumputils.h"
29#include "filter.h"
30#include "getopt_long.h"
31#include "pg_backup.h"
32
33/* version string we expect back from pg_dump */
34#define PGDUMP_VERSIONSTR "pg_dump (PostgreSQL) " PG_VERSION "\n"
35
36typedef struct
37{
40 char *rolename;
42
43#define SH_PREFIX rolename
44#define SH_ELEMENT_TYPE RoleNameEntry
45#define SH_KEY_TYPE char *
46#define SH_KEY rolename
47#define SH_HASH_KEY(tb, key) hash_string(key)
48#define SH_EQUAL(tb, a, b) (strcmp(a, b) == 0)
49#define SH_STORE_HASH
50#define SH_GET_HASH(tb, a) (a)->hashval
51#define SH_SCOPE static inline
52#define SH_RAW_ALLOCATOR pg_malloc0
53#define SH_DECLARE
54#define SH_DEFINE
55#include "lib/simplehash.h"
56
57static void help(void);
58
59static void dropRoles(PGconn *conn);
60static void dumpRoles(PGconn *conn);
61static void dumpRoleMembership(PGconn *conn);
62static void dumpRoleGUCPrivs(PGconn *conn);
63static void dropTablespaces(PGconn *conn);
64static void dumpTablespaces(PGconn *conn);
65static void dropDBs(PGconn *conn);
66static void dumpUserConfig(PGconn *conn, const char *username);
67static void dumpDatabases(PGconn *conn);
68static void dumpTimestamp(const char *msg);
69static int runPgDump(const char *dbname, const char *create_opts);
70static void buildShSecLabels(PGconn *conn,
71 const char *catalog_name, Oid objectId,
72 const char *objtype, const char *objname,
73 PQExpBuffer buffer);
74static PGconn *connectDatabase(const char *dbname,
75 const char *connection_string, const char *pghost,
76 const char *pgport, const char *pguser,
77 trivalue prompt_password, bool fail_on_error);
78static char *constructConnStr(const char **keywords, const char **values);
79static PGresult *executeQuery(PGconn *conn, const char *query);
80static void executeCommand(PGconn *conn, const char *query);
82 SimpleStringList *names);
83static void read_dumpall_filters(const char *filename, SimpleStringList *pattern);
84
86static const char *progname;
88static char *connstr = "";
89static bool output_clean = false;
90static bool skip_acls = false;
91static bool verbose = false;
92static bool dosync = true;
93
94static int binary_upgrade = 0;
95static int column_inserts = 0;
97static int disable_triggers = 0;
98static int if_exists = 0;
99static int inserts = 0;
101static int no_tablespaces = 0;
102static int use_setsessauth = 0;
103static int no_comments = 0;
104static int no_publications = 0;
105static int no_security_labels = 0;
106static int no_subscriptions = 0;
107static int no_toast_compression = 0;
109static int no_role_passwords = 0;
110static int server_version;
113
114static char role_catalog[10];
115#define PG_AUTHID "pg_authid"
116#define PG_ROLES "pg_roles "
117
118static FILE *OPF;
119static char *filename = NULL;
120
123
124#define exit_nicely(code) exit(code)
125
126int
127main(int argc, char *argv[])
128{
129 static struct option long_options[] = {
130 {"data-only", no_argument, NULL, 'a'},
131 {"clean", no_argument, NULL, 'c'},
132 {"encoding", required_argument, NULL, 'E'},
133 {"file", required_argument, NULL, 'f'},
134 {"globals-only", no_argument, NULL, 'g'},
135 {"host", required_argument, NULL, 'h'},
136 {"dbname", required_argument, NULL, 'd'},
137 {"database", required_argument, NULL, 'l'},
138 {"no-owner", no_argument, NULL, 'O'},
139 {"port", required_argument, NULL, 'p'},
140 {"roles-only", no_argument, NULL, 'r'},
141 {"schema-only", no_argument, NULL, 's'},
142 {"superuser", required_argument, NULL, 'S'},
143 {"tablespaces-only", no_argument, NULL, 't'},
144 {"username", required_argument, NULL, 'U'},
145 {"verbose", no_argument, NULL, 'v'},
146 {"no-password", no_argument, NULL, 'w'},
147 {"password", no_argument, NULL, 'W'},
148 {"no-privileges", no_argument, NULL, 'x'},
149 {"no-acl", no_argument, NULL, 'x'},
150
151 /*
152 * the following options don't have an equivalent short option letter
153 */
154 {"attribute-inserts", no_argument, &column_inserts, 1},
155 {"binary-upgrade", no_argument, &binary_upgrade, 1},
156 {"column-inserts", no_argument, &column_inserts, 1},
157 {"disable-dollar-quoting", no_argument, &disable_dollar_quoting, 1},
158 {"disable-triggers", no_argument, &disable_triggers, 1},
159 {"exclude-database", required_argument, NULL, 6},
160 {"extra-float-digits", required_argument, NULL, 5},
161 {"if-exists", no_argument, &if_exists, 1},
162 {"inserts", no_argument, &inserts, 1},
163 {"lock-wait-timeout", required_argument, NULL, 2},
164 {"no-table-access-method", no_argument, &no_table_access_method, 1},
165 {"no-tablespaces", no_argument, &no_tablespaces, 1},
166 {"quote-all-identifiers", no_argument, &quote_all_identifiers, 1},
167 {"load-via-partition-root", no_argument, &load_via_partition_root, 1},
168 {"role", required_argument, NULL, 3},
169 {"use-set-session-authorization", no_argument, &use_setsessauth, 1},
170 {"no-comments", no_argument, &no_comments, 1},
171 {"no-publications", no_argument, &no_publications, 1},
172 {"no-role-passwords", no_argument, &no_role_passwords, 1},
173 {"no-security-labels", no_argument, &no_security_labels, 1},
174 {"no-subscriptions", no_argument, &no_subscriptions, 1},
175 {"no-sync", no_argument, NULL, 4},
176 {"no-toast-compression", no_argument, &no_toast_compression, 1},
177 {"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
178 {"on-conflict-do-nothing", no_argument, &on_conflict_do_nothing, 1},
179 {"rows-per-insert", required_argument, NULL, 7},
180 {"filter", required_argument, NULL, 8},
181
182 {NULL, 0, NULL, 0}
183 };
184
185 char *pghost = NULL;
186 char *pgport = NULL;
187 char *pguser = NULL;
188 char *pgdb = NULL;
189 char *use_role = NULL;
190 const char *dumpencoding = NULL;
191 trivalue prompt_password = TRI_DEFAULT;
192 bool data_only = false;
193 bool globals_only = false;
194 bool roles_only = false;
195 bool tablespaces_only = false;
196 PGconn *conn;
197 int encoding;
198 const char *std_strings;
199 int c,
200 ret;
201 int optindex;
202
203 pg_logging_init(argv[0]);
205 set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_dump"));
206 progname = get_progname(argv[0]);
207
208 if (argc > 1)
209 {
210 if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
211 {
212 help();
213 exit_nicely(0);
214 }
215 if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
216 {
217 puts("pg_dumpall (PostgreSQL) " PG_VERSION);
218 exit_nicely(0);
219 }
220 }
221
222 if ((ret = find_other_exec(argv[0], "pg_dump", PGDUMP_VERSIONSTR,
223 pg_dump_bin)) < 0)
224 {
225 char full_path[MAXPGPATH];
226
227 if (find_my_exec(argv[0], full_path) < 0)
228 strlcpy(full_path, progname, sizeof(full_path));
229
230 if (ret == -1)
231 pg_fatal("program \"%s\" is needed by %s but was not found in the same directory as \"%s\"",
232 "pg_dump", progname, full_path);
233 else
234 pg_fatal("program \"%s\" was found by \"%s\" but was not the same version as %s",
235 "pg_dump", full_path, progname);
236 }
237
239
240 while ((c = getopt_long(argc, argv, "acd:E:f:gh:l:Op:rsS:tU:vwWx", long_options, &optindex)) != -1)
241 {
242 switch (c)
243 {
244 case 'a':
245 data_only = true;
247 break;
248
249 case 'c':
250 output_clean = true;
251 break;
252
253 case 'd':
255 break;
256
257 case 'E':
258 dumpencoding = pg_strdup(optarg);
261 break;
262
263 case 'f':
267 break;
268
269 case 'g':
270 globals_only = true;
271 break;
272
273 case 'h':
275 break;
276
277 case 'l':
278 pgdb = pg_strdup(optarg);
279 break;
280
281 case 'O':
283 break;
284
285 case 'p':
287 break;
288
289 case 'r':
290 roles_only = true;
291 break;
292
293 case 's':
295 break;
296
297 case 'S':
300 break;
301
302 case 't':
303 tablespaces_only = true;
304 break;
305
306 case 'U':
307 pguser = pg_strdup(optarg);
308 break;
309
310 case 'v':
311 verbose = true;
314 break;
315
316 case 'w':
317 prompt_password = TRI_NO;
319 break;
320
321 case 'W':
322 prompt_password = TRI_YES;
324 break;
325
326 case 'x':
327 skip_acls = true;
329 break;
330
331 case 0:
332 break;
333
334 case 2:
335 appendPQExpBufferStr(pgdumpopts, " --lock-wait-timeout ");
337 break;
338
339 case 3:
340 use_role = pg_strdup(optarg);
341 appendPQExpBufferStr(pgdumpopts, " --role ");
342 appendShellString(pgdumpopts, use_role);
343 break;
344
345 case 4:
346 dosync = false;
347 appendPQExpBufferStr(pgdumpopts, " --no-sync");
348 break;
349
350 case 5:
351 appendPQExpBufferStr(pgdumpopts, " --extra-float-digits ");
353 break;
354
355 case 6:
357 break;
358
359 case 7:
360 appendPQExpBufferStr(pgdumpopts, " --rows-per-insert ");
362 break;
363
364 case 8:
366 break;
367
368 default:
369 /* getopt_long already emitted a complaint */
370 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
371 exit_nicely(1);
372 }
373 }
374
375 /* Complain if any arguments remain */
376 if (optind < argc)
377 {
378 pg_log_error("too many command-line arguments (first is \"%s\")",
379 argv[optind]);
380 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
381 exit_nicely(1);
382 }
383
384 if (database_exclude_patterns.head != NULL &&
385 (globals_only || roles_only || tablespaces_only))
386 {
387 pg_log_error("option --exclude-database cannot be used together with -g/--globals-only, -r/--roles-only, or -t/--tablespaces-only");
388 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
389 exit_nicely(1);
390 }
391
392 /* Make sure the user hasn't specified a mix of globals-only options */
393 if (globals_only && roles_only)
394 {
395 pg_log_error("options -g/--globals-only and -r/--roles-only cannot be used together");
396 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
397 exit_nicely(1);
398 }
399
400 if (globals_only && tablespaces_only)
401 {
402 pg_log_error("options -g/--globals-only and -t/--tablespaces-only cannot be used together");
403 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
404 exit_nicely(1);
405 }
406
407 if (if_exists && !output_clean)
408 pg_fatal("option --if-exists requires option -c/--clean");
409
410 if (roles_only && tablespaces_only)
411 {
412 pg_log_error("options -r/--roles-only and -t/--tablespaces-only cannot be used together");
413 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
414 exit_nicely(1);
415 }
416
417 /*
418 * If password values are not required in the dump, switch to using
419 * pg_roles which is equally useful, just more likely to have unrestricted
420 * access than pg_authid.
421 */
424 else
426
427 /* Add long options to the pg_dump argument list */
428 if (binary_upgrade)
429 appendPQExpBufferStr(pgdumpopts, " --binary-upgrade");
430 if (column_inserts)
431 appendPQExpBufferStr(pgdumpopts, " --column-inserts");
433 appendPQExpBufferStr(pgdumpopts, " --disable-dollar-quoting");
435 appendPQExpBufferStr(pgdumpopts, " --disable-triggers");
436 if (inserts)
437 appendPQExpBufferStr(pgdumpopts, " --inserts");
439 appendPQExpBufferStr(pgdumpopts, " --no-table-access-method");
440 if (no_tablespaces)
441 appendPQExpBufferStr(pgdumpopts, " --no-tablespaces");
443 appendPQExpBufferStr(pgdumpopts, " --quote-all-identifiers");
445 appendPQExpBufferStr(pgdumpopts, " --load-via-partition-root");
446 if (use_setsessauth)
447 appendPQExpBufferStr(pgdumpopts, " --use-set-session-authorization");
448 if (no_comments)
449 appendPQExpBufferStr(pgdumpopts, " --no-comments");
450 if (no_publications)
451 appendPQExpBufferStr(pgdumpopts, " --no-publications");
453 appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
455 appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
457 appendPQExpBufferStr(pgdumpopts, " --no-toast-compression");
459 appendPQExpBufferStr(pgdumpopts, " --no-unlogged-table-data");
461 appendPQExpBufferStr(pgdumpopts, " --on-conflict-do-nothing");
462
463 /*
464 * If there was a database specified on the command line, use that,
465 * otherwise try to connect to database "postgres", and failing that
466 * "template1".
467 */
468 if (pgdb)
469 {
470 conn = connectDatabase(pgdb, connstr, pghost, pgport, pguser,
471 prompt_password, false);
472
473 if (!conn)
474 pg_fatal("could not connect to database \"%s\"", pgdb);
475 }
476 else
477 {
478 conn = connectDatabase("postgres", connstr, pghost, pgport, pguser,
479 prompt_password, false);
480 if (!conn)
481 conn = connectDatabase("template1", connstr, pghost, pgport, pguser,
482 prompt_password, true);
483
484 if (!conn)
485 {
486 pg_log_error("could not connect to databases \"postgres\" or \"template1\"\n"
487 "Please specify an alternative database.");
488 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
489 exit_nicely(1);
490 }
491 }
492
493 /*
494 * Get a list of database names that match the exclude patterns
495 */
498
499 /*
500 * Open the output file if required, otherwise use stdout
501 */
502 if (filename)
503 {
504 OPF = fopen(filename, PG_BINARY_W);
505 if (!OPF)
506 pg_fatal("could not open output file \"%s\": %m",
507 filename);
508 }
509 else
510 OPF = stdout;
511
512 /*
513 * Set the client encoding if requested.
514 */
515 if (dumpencoding)
516 {
517 if (PQsetClientEncoding(conn, dumpencoding) < 0)
518 pg_fatal("invalid client encoding \"%s\" specified",
519 dumpencoding);
520 }
521
522 /*
523 * Get the active encoding and the standard_conforming_strings setting, so
524 * we know how to escape strings.
525 */
527 std_strings = PQparameterStatus(conn, "standard_conforming_strings");
528 if (!std_strings)
529 std_strings = "off";
530
531 /* Set the role if requested */
532 if (use_role)
533 {
535
536 appendPQExpBuffer(query, "SET ROLE %s", fmtId(use_role));
537 executeCommand(conn, query->data);
538 destroyPQExpBuffer(query);
539 }
540
541 /* Force quoting of all identifiers if requested. */
543 executeCommand(conn, "SET quote_all_identifiers = true");
544
545 fprintf(OPF, "--\n-- PostgreSQL database cluster dump\n--\n\n");
546 if (verbose)
547 dumpTimestamp("Started on");
548
549 /*
550 * We used to emit \connect postgres here, but that served no purpose
551 * other than to break things for installations without a postgres
552 * database. Everything we're restoring here is a global, so whichever
553 * database we're connected to at the moment is fine.
554 */
555
556 /* Restore will need to write to the target cluster */
557 fprintf(OPF, "SET default_transaction_read_only = off;\n\n");
558
559 /* Replicate encoding and std_strings in output */
560 fprintf(OPF, "SET client_encoding = '%s';\n",
562 fprintf(OPF, "SET standard_conforming_strings = %s;\n", std_strings);
563 if (strcmp(std_strings, "off") == 0)
564 fprintf(OPF, "SET escape_string_warning = off;\n");
565 fprintf(OPF, "\n");
566
567 if (!data_only)
568 {
569 /*
570 * If asked to --clean, do that first. We can avoid detailed
571 * dependency analysis because databases never depend on each other,
572 * and tablespaces never depend on each other. Roles could have
573 * grants to each other, but DROP ROLE will clean those up silently.
574 */
575 if (output_clean)
576 {
577 if (!globals_only && !roles_only && !tablespaces_only)
578 dropDBs(conn);
579
580 if (!roles_only && !no_tablespaces)
582
583 if (!tablespaces_only)
585 }
586
587 /*
588 * Now create objects as requested. Be careful that option logic here
589 * is the same as for drops above.
590 */
591 if (!tablespaces_only)
592 {
593 /* Dump roles (users) */
595
596 /* Dump role memberships */
598
599 /* Dump role GUC privileges */
600 if (server_version >= 150000 && !skip_acls)
602 }
603
604 /* Dump tablespaces */
605 if (!roles_only && !no_tablespaces)
607 }
608
609 if (!globals_only && !roles_only && !tablespaces_only)
611
612 PQfinish(conn);
613
614 if (verbose)
615 dumpTimestamp("Completed on");
616 fprintf(OPF, "--\n-- PostgreSQL database cluster dump complete\n--\n\n");
617
618 if (filename)
619 {
620 fclose(OPF);
621
622 /* sync the resulting file, errors are not fatal */
623 if (dosync)
624 (void) fsync_fname(filename, false);
625 }
626
627 exit_nicely(0);
628}
629
630
631static void
632help(void)
633{
634 printf(_("%s extracts a PostgreSQL database cluster into an SQL script file.\n\n"), progname);
635 printf(_("Usage:\n"));
636 printf(_(" %s [OPTION]...\n"), progname);
637
638 printf(_("\nGeneral options:\n"));
639 printf(_(" -f, --file=FILENAME output file name\n"));
640 printf(_(" -v, --verbose verbose mode\n"));
641 printf(_(" -V, --version output version information, then exit\n"));
642 printf(_(" --lock-wait-timeout=TIMEOUT fail after waiting TIMEOUT for a table lock\n"));
643 printf(_(" -?, --help show this help, then exit\n"));
644 printf(_("\nOptions controlling the output content:\n"));
645 printf(_(" -a, --data-only dump only the data, not the schema\n"));
646 printf(_(" -c, --clean clean (drop) databases before recreating\n"));
647 printf(_(" -E, --encoding=ENCODING dump the data in encoding ENCODING\n"));
648 printf(_(" -g, --globals-only dump only global objects, no databases\n"));
649 printf(_(" -O, --no-owner skip restoration of object ownership\n"));
650 printf(_(" -r, --roles-only dump only roles, no databases or tablespaces\n"));
651 printf(_(" -s, --schema-only dump only the schema, no data\n"));
652 printf(_(" -S, --superuser=NAME superuser user name to use in the dump\n"));
653 printf(_(" -t, --tablespaces-only dump only tablespaces, no databases or roles\n"));
654 printf(_(" -x, --no-privileges do not dump privileges (grant/revoke)\n"));
655 printf(_(" --binary-upgrade for use by upgrade utilities only\n"));
656 printf(_(" --column-inserts dump data as INSERT commands with column names\n"));
657 printf(_(" --disable-dollar-quoting disable dollar quoting, use SQL standard quoting\n"));
658 printf(_(" --disable-triggers disable triggers during data-only restore\n"));
659 printf(_(" --exclude-database=PATTERN exclude databases whose name matches PATTERN\n"));
660 printf(_(" --extra-float-digits=NUM override default setting for extra_float_digits\n"));
661 printf(_(" --filter=FILENAME exclude databases based on expressions in FILENAME\n"));
662 printf(_(" --if-exists use IF EXISTS when dropping objects\n"));
663 printf(_(" --inserts dump data as INSERT commands, rather than COPY\n"));
664 printf(_(" --load-via-partition-root load partitions via the root table\n"));
665 printf(_(" --no-comments do not dump comment commands\n"));
666 printf(_(" --no-publications do not dump publications\n"));
667 printf(_(" --no-role-passwords do not dump passwords for roles\n"));
668 printf(_(" --no-security-labels do not dump security label assignments\n"));
669 printf(_(" --no-subscriptions do not dump subscriptions\n"));
670 printf(_(" --no-sync do not wait for changes to be written safely to disk\n"));
671 printf(_(" --no-table-access-method do not dump table access methods\n"));
672 printf(_(" --no-tablespaces do not dump tablespace assignments\n"));
673 printf(_(" --no-toast-compression do not dump TOAST compression methods\n"));
674 printf(_(" --no-unlogged-table-data do not dump unlogged table data\n"));
675 printf(_(" --on-conflict-do-nothing add ON CONFLICT DO NOTHING to INSERT commands\n"));
676 printf(_(" --quote-all-identifiers quote all identifiers, even if not key words\n"));
677 printf(_(" --rows-per-insert=NROWS number of rows per INSERT; implies --inserts\n"));
678 printf(_(" --use-set-session-authorization\n"
679 " use SET SESSION AUTHORIZATION commands instead of\n"
680 " ALTER OWNER commands to set ownership\n"));
681
682 printf(_("\nConnection options:\n"));
683 printf(_(" -d, --dbname=CONNSTR connect using connection string\n"));
684 printf(_(" -h, --host=HOSTNAME database server host or socket directory\n"));
685 printf(_(" -l, --database=DBNAME alternative default database\n"));
686 printf(_(" -p, --port=PORT database server port number\n"));
687 printf(_(" -U, --username=NAME connect as specified database user\n"));
688 printf(_(" -w, --no-password never prompt for password\n"));
689 printf(_(" -W, --password force password prompt (should happen automatically)\n"));
690 printf(_(" --role=ROLENAME do SET ROLE before dump\n"));
691
692 printf(_("\nIf -f/--file is not used, then the SQL script will be written to the standard\n"
693 "output.\n\n"));
694 printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
695 printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
696}
697
698
699/*
700 * Drop roles
701 */
702static void
704{
706 PGresult *res;
707 int i_rolname;
708 int i;
709
710 if (server_version >= 90600)
712 "SELECT rolname "
713 "FROM %s "
714 "WHERE rolname !~ '^pg_' "
715 "ORDER BY 1", role_catalog);
716 else
718 "SELECT rolname "
719 "FROM %s "
720 "ORDER BY 1", role_catalog);
721
722 res = executeQuery(conn, buf->data);
723
724 i_rolname = PQfnumber(res, "rolname");
725
726 if (PQntuples(res) > 0)
727 fprintf(OPF, "--\n-- Drop roles\n--\n\n");
728
729 for (i = 0; i < PQntuples(res); i++)
730 {
731 const char *rolename;
732
733 rolename = PQgetvalue(res, i, i_rolname);
734
735 fprintf(OPF, "DROP ROLE %s%s;\n",
736 if_exists ? "IF EXISTS " : "",
737 fmtId(rolename));
738 }
739
740 PQclear(res);
742
743 fprintf(OPF, "\n\n");
744}
745
746/*
747 * Dump roles
748 */
749static void
751{
753 PGresult *res;
754 int i_oid,
755 i_rolname,
756 i_rolsuper,
757 i_rolinherit,
758 i_rolcreaterole,
759 i_rolcreatedb,
760 i_rolcanlogin,
761 i_rolconnlimit,
762 i_rolpassword,
763 i_rolvaliduntil,
764 i_rolreplication,
765 i_rolbypassrls,
766 i_rolcomment,
767 i_is_current_user;
768 int i;
769
770 /*
771 * Notes: rolconfig is dumped later, and pg_authid must be used for
772 * extracting rolcomment regardless of role_catalog.
773 */
774 if (server_version >= 90600)
776 "SELECT oid, rolname, rolsuper, rolinherit, "
777 "rolcreaterole, rolcreatedb, "
778 "rolcanlogin, rolconnlimit, rolpassword, "
779 "rolvaliduntil, rolreplication, rolbypassrls, "
780 "pg_catalog.shobj_description(oid, 'pg_authid') as rolcomment, "
781 "rolname = current_user AS is_current_user "
782 "FROM %s "
783 "WHERE rolname !~ '^pg_' "
784 "ORDER BY 2", role_catalog);
785 else if (server_version >= 90500)
787 "SELECT oid, rolname, rolsuper, rolinherit, "
788 "rolcreaterole, rolcreatedb, "
789 "rolcanlogin, rolconnlimit, rolpassword, "
790 "rolvaliduntil, rolreplication, rolbypassrls, "
791 "pg_catalog.shobj_description(oid, 'pg_authid') as rolcomment, "
792 "rolname = current_user AS is_current_user "
793 "FROM %s "
794 "ORDER BY 2", role_catalog);
795 else
797 "SELECT oid, rolname, rolsuper, rolinherit, "
798 "rolcreaterole, rolcreatedb, "
799 "rolcanlogin, rolconnlimit, rolpassword, "
800 "rolvaliduntil, rolreplication, "
801 "false as rolbypassrls, "
802 "pg_catalog.shobj_description(oid, 'pg_authid') as rolcomment, "
803 "rolname = current_user AS is_current_user "
804 "FROM %s "
805 "ORDER BY 2", role_catalog);
806
807 res = executeQuery(conn, buf->data);
808
809 i_oid = PQfnumber(res, "oid");
810 i_rolname = PQfnumber(res, "rolname");
811 i_rolsuper = PQfnumber(res, "rolsuper");
812 i_rolinherit = PQfnumber(res, "rolinherit");
813 i_rolcreaterole = PQfnumber(res, "rolcreaterole");
814 i_rolcreatedb = PQfnumber(res, "rolcreatedb");
815 i_rolcanlogin = PQfnumber(res, "rolcanlogin");
816 i_rolconnlimit = PQfnumber(res, "rolconnlimit");
817 i_rolpassword = PQfnumber(res, "rolpassword");
818 i_rolvaliduntil = PQfnumber(res, "rolvaliduntil");
819 i_rolreplication = PQfnumber(res, "rolreplication");
820 i_rolbypassrls = PQfnumber(res, "rolbypassrls");
821 i_rolcomment = PQfnumber(res, "rolcomment");
822 i_is_current_user = PQfnumber(res, "is_current_user");
823
824 if (PQntuples(res) > 0)
825 fprintf(OPF, "--\n-- Roles\n--\n\n");
826
827 for (i = 0; i < PQntuples(res); i++)
828 {
829 const char *rolename;
830 Oid auth_oid;
831
832 auth_oid = atooid(PQgetvalue(res, i, i_oid));
833 rolename = PQgetvalue(res, i, i_rolname);
834
835 if (strncmp(rolename, "pg_", 3) == 0)
836 {
837 pg_log_warning("role name starting with \"pg_\" skipped (%s)",
838 rolename);
839 continue;
840 }
841
843
844 if (binary_upgrade)
845 {
846 appendPQExpBufferStr(buf, "\n-- For binary upgrade, must preserve pg_authid.oid\n");
848 "SELECT pg_catalog.binary_upgrade_set_next_pg_authid_oid('%u'::pg_catalog.oid);\n\n",
849 auth_oid);
850 }
851
852 /*
853 * We dump CREATE ROLE followed by ALTER ROLE to ensure that the role
854 * will acquire the right properties even if it already exists (ie, it
855 * won't hurt for the CREATE to fail). This is particularly important
856 * for the role we are connected as, since even with --clean we will
857 * have failed to drop it. binary_upgrade cannot generate any errors,
858 * so we assume the current role is already created.
859 */
860 if (!binary_upgrade ||
861 strcmp(PQgetvalue(res, i, i_is_current_user), "f") == 0)
862 appendPQExpBuffer(buf, "CREATE ROLE %s;\n", fmtId(rolename));
863 appendPQExpBuffer(buf, "ALTER ROLE %s WITH", fmtId(rolename));
864
865 if (strcmp(PQgetvalue(res, i, i_rolsuper), "t") == 0)
866 appendPQExpBufferStr(buf, " SUPERUSER");
867 else
868 appendPQExpBufferStr(buf, " NOSUPERUSER");
869
870 if (strcmp(PQgetvalue(res, i, i_rolinherit), "t") == 0)
871 appendPQExpBufferStr(buf, " INHERIT");
872 else
873 appendPQExpBufferStr(buf, " NOINHERIT");
874
875 if (strcmp(PQgetvalue(res, i, i_rolcreaterole), "t") == 0)
876 appendPQExpBufferStr(buf, " CREATEROLE");
877 else
878 appendPQExpBufferStr(buf, " NOCREATEROLE");
879
880 if (strcmp(PQgetvalue(res, i, i_rolcreatedb), "t") == 0)
881 appendPQExpBufferStr(buf, " CREATEDB");
882 else
883 appendPQExpBufferStr(buf, " NOCREATEDB");
884
885 if (strcmp(PQgetvalue(res, i, i_rolcanlogin), "t") == 0)
886 appendPQExpBufferStr(buf, " LOGIN");
887 else
888 appendPQExpBufferStr(buf, " NOLOGIN");
889
890 if (strcmp(PQgetvalue(res, i, i_rolreplication), "t") == 0)
891 appendPQExpBufferStr(buf, " REPLICATION");
892 else
893 appendPQExpBufferStr(buf, " NOREPLICATION");
894
895 if (strcmp(PQgetvalue(res, i, i_rolbypassrls), "t") == 0)
896 appendPQExpBufferStr(buf, " BYPASSRLS");
897 else
898 appendPQExpBufferStr(buf, " NOBYPASSRLS");
899
900 if (strcmp(PQgetvalue(res, i, i_rolconnlimit), "-1") != 0)
901 appendPQExpBuffer(buf, " CONNECTION LIMIT %s",
902 PQgetvalue(res, i, i_rolconnlimit));
903
904
905 if (!PQgetisnull(res, i, i_rolpassword) && !no_role_passwords)
906 {
907 appendPQExpBufferStr(buf, " PASSWORD ");
908 appendStringLiteralConn(buf, PQgetvalue(res, i, i_rolpassword), conn);
909 }
910
911 if (!PQgetisnull(res, i, i_rolvaliduntil))
912 appendPQExpBuffer(buf, " VALID UNTIL '%s'",
913 PQgetvalue(res, i, i_rolvaliduntil));
914
916
917 if (!no_comments && !PQgetisnull(res, i, i_rolcomment))
918 {
919 appendPQExpBuffer(buf, "COMMENT ON ROLE %s IS ", fmtId(rolename));
920 appendStringLiteralConn(buf, PQgetvalue(res, i, i_rolcomment), conn);
922 }
923
925 buildShSecLabels(conn, "pg_authid", auth_oid,
926 "ROLE", rolename,
927 buf);
928
929 fprintf(OPF, "%s", buf->data);
930 }
931
932 /*
933 * Dump configuration settings for roles after all roles have been dumped.
934 * We do it this way because config settings for roles could mention the
935 * names of other roles.
936 */
937 if (PQntuples(res) > 0)
938 fprintf(OPF, "\n--\n-- User Configurations\n--\n");
939
940 for (i = 0; i < PQntuples(res); i++)
941 dumpUserConfig(conn, PQgetvalue(res, i, i_rolname));
942
943 PQclear(res);
944
945 fprintf(OPF, "\n\n");
946
948}
949
950
951/*
952 * Dump role memberships.
953 *
954 * Note: we expect dumpRoles already created all the roles, but there is
955 * no membership yet.
956 */
957static void
959{
962 PGresult *res;
963 int start = 0,
964 end,
965 total;
966 bool dump_grantors;
967 bool dump_grant_options;
968 int i_inherit_option;
969 int i_set_option;
970
971 /*
972 * Previous versions of PostgreSQL didn't used to track the grantor very
973 * carefully in the backend, and the grantor could be any user even if
974 * they didn't have ADMIN OPTION on the role, or a user that no longer
975 * existed. To avoid dump and restore failures, don't dump the grantor
976 * when talking to an old server version.
977 */
978 dump_grantors = (PQserverVersion(conn) >= 160000);
979
980 /*
981 * Previous versions of PostgreSQL also did not have grant-level options.
982 */
983 dump_grant_options = (server_version >= 160000);
984
985 /* Generate and execute query. */
986 printfPQExpBuffer(buf, "SELECT ur.rolname AS role, "
987 "um.rolname AS member, "
988 "ug.oid AS grantorid, "
989 "ug.rolname AS grantor, "
990 "a.admin_option");
991 if (dump_grant_options)
992 appendPQExpBufferStr(buf, ", a.inherit_option, a.set_option");
993 appendPQExpBuffer(buf, " FROM pg_auth_members a "
994 "LEFT JOIN %s ur on ur.oid = a.roleid "
995 "LEFT JOIN %s um on um.oid = a.member "
996 "LEFT JOIN %s ug on ug.oid = a.grantor "
997 "WHERE NOT (ur.rolname ~ '^pg_' AND um.rolname ~ '^pg_')"
998 "ORDER BY 1,2,4", role_catalog, role_catalog, role_catalog);
999 res = executeQuery(conn, buf->data);
1000 i_inherit_option = PQfnumber(res, "inherit_option");
1001 i_set_option = PQfnumber(res, "set_option");
1002
1003 if (PQntuples(res) > 0)
1004 fprintf(OPF, "--\n-- Role memberships\n--\n\n");
1005
1006 /*
1007 * We can't dump these GRANT commands in arbitrary order, because a role
1008 * that is named as a grantor must already have ADMIN OPTION on the role
1009 * for which it is granting permissions, except for the bootstrap
1010 * superuser, who can always be named as the grantor.
1011 *
1012 * We handle this by considering these grants role by role. For each role,
1013 * we initially consider the only allowable grantor to be the bootstrap
1014 * superuser. Every time we grant ADMIN OPTION on the role to some user,
1015 * that user also becomes an allowable grantor. We make repeated passes
1016 * over the grants for the role, each time dumping those whose grantors
1017 * are allowable and which we haven't done yet. Eventually this should let
1018 * us dump all the grants.
1019 */
1020 total = PQntuples(res);
1021 while (start < total)
1022 {
1023 char *role = PQgetvalue(res, start, 0);
1024 int i;
1025 bool *done;
1026 int remaining;
1027 int prev_remaining = 0;
1028 rolename_hash *ht;
1029
1030 /* All memberships for a single role should be adjacent. */
1031 for (end = start; end < total; ++end)
1032 {
1033 char *otherrole;
1034
1035 otherrole = PQgetvalue(res, end, 0);
1036 if (strcmp(role, otherrole) != 0)
1037 break;
1038 }
1039
1040 role = PQgetvalue(res, start, 0);
1041 remaining = end - start;
1042 done = pg_malloc0(remaining * sizeof(bool));
1043 ht = rolename_create(remaining, NULL);
1044
1045 /*
1046 * Make repeated passes over the grants for this role until all have
1047 * been dumped.
1048 */
1049 while (remaining > 0)
1050 {
1051 /*
1052 * We should make progress on every iteration, because a notional
1053 * graph whose vertices are grants and whose edges point from
1054 * grantors to members should be connected and acyclic. If we fail
1055 * to make progress, either we or the server have messed up.
1056 */
1057 if (remaining == prev_remaining)
1058 {
1059 pg_log_error("could not find a legal dump ordering for memberships in role \"%s\"",
1060 role);
1061 PQfinish(conn);
1062 exit_nicely(1);
1063 }
1064 prev_remaining = remaining;
1065
1066 /* Make one pass over the grants for this role. */
1067 for (i = start; i < end; ++i)
1068 {
1069 char *member;
1070 char *admin_option;
1071 char *grantorid;
1072 char *grantor;
1073 char *set_option = "true";
1074 bool found;
1075
1076 /* If we already did this grant, don't do it again. */
1077 if (done[i - start])
1078 continue;
1079
1080 member = PQgetvalue(res, i, 1);
1081 grantorid = PQgetvalue(res, i, 2);
1082 grantor = PQgetvalue(res, i, 3);
1084 if (dump_grant_options)
1085 set_option = PQgetvalue(res, i, i_set_option);
1086
1087 /*
1088 * If we're not dumping grantors or if the grantor is the
1089 * bootstrap superuser, it's fine to dump this now. Otherwise,
1090 * it's got to be someone who has already been granted ADMIN
1091 * OPTION.
1092 */
1093 if (dump_grantors &&
1094 atooid(grantorid) != BOOTSTRAP_SUPERUSERID &&
1095 rolename_lookup(ht, grantor) == NULL)
1096 continue;
1097
1098 /* Remember that we did this so that we don't do it again. */
1099 done[i - start] = true;
1100 --remaining;
1101
1102 /*
1103 * If ADMIN OPTION is being granted, remember that grants
1104 * listing this member as the grantor can now be dumped.
1105 */
1106 if (*admin_option == 't')
1107 rolename_insert(ht, member, &found);
1108
1109 /* Generate the actual GRANT statement. */
1110 resetPQExpBuffer(optbuf);
1111 fprintf(OPF, "GRANT %s", fmtId(role));
1112 fprintf(OPF, " TO %s", fmtId(member));
1113 if (*admin_option == 't')
1114 appendPQExpBufferStr(optbuf, "ADMIN OPTION");
1115 if (dump_grant_options)
1116 {
1117 char *inherit_option;
1118
1119 if (optbuf->data[0] != '\0')
1120 appendPQExpBufferStr(optbuf, ", ");
1121 inherit_option = PQgetvalue(res, i, i_inherit_option);
1122 appendPQExpBuffer(optbuf, "INHERIT %s",
1123 *inherit_option == 't' ?
1124 "TRUE" : "FALSE");
1125 }
1126 if (*set_option != 't')
1127 {
1128 if (optbuf->data[0] != '\0')
1129 appendPQExpBufferStr(optbuf, ", ");
1130 appendPQExpBuffer(optbuf, "SET FALSE");
1131 }
1132 if (optbuf->data[0] != '\0')
1133 fprintf(OPF, " WITH %s", optbuf->data);
1134 if (dump_grantors)
1135 fprintf(OPF, " GRANTED BY %s", fmtId(grantor));
1136 fprintf(OPF, ";\n");
1137 }
1138 }
1139
1140 rolename_destroy(ht);
1141 pg_free(done);
1142 start = end;
1143 }
1144
1145 PQclear(res);
1147
1148 fprintf(OPF, "\n\n");
1149}
1150
1151
1152/*
1153 * Dump role configuration parameter privileges. This code is used for 15.0
1154 * and later servers.
1155 *
1156 * Note: we expect dumpRoles already created all the roles, but there are
1157 * no per-role configuration parameter privileges yet.
1158 */
1159static void
1161{
1162 PGresult *res;
1163 int i;
1164
1165 /*
1166 * Get all parameters that have non-default acls defined.
1167 */
1168 res = executeQuery(conn, "SELECT parname, "
1169 "pg_catalog.pg_get_userbyid(" CppAsString2(BOOTSTRAP_SUPERUSERID) ") AS parowner, "
1170 "paracl, "
1171 "pg_catalog.acldefault('p', " CppAsString2(BOOTSTRAP_SUPERUSERID) ") AS acldefault "
1172 "FROM pg_catalog.pg_parameter_acl "
1173 "ORDER BY 1");
1174
1175 if (PQntuples(res) > 0)
1176 fprintf(OPF, "--\n-- Role privileges on configuration parameters\n--\n\n");
1177
1178 for (i = 0; i < PQntuples(res); i++)
1179 {
1181 char *parname = PQgetvalue(res, i, 0);
1182 char *parowner = PQgetvalue(res, i, 1);
1183 char *paracl = PQgetvalue(res, i, 2);
1184 char *acldefault = PQgetvalue(res, i, 3);
1185 char *fparname;
1186
1187 /* needed for buildACLCommands() */
1188 fparname = pg_strdup(fmtId(parname));
1189
1190 if (!buildACLCommands(fparname, NULL, NULL, "PARAMETER",
1191 paracl, acldefault,
1192 parowner, "", server_version, buf))
1193 {
1194 pg_log_error("could not parse ACL list (%s) for parameter \"%s\"",
1195 paracl, parname);
1196 PQfinish(conn);
1197 exit_nicely(1);
1198 }
1199
1200 fprintf(OPF, "%s", buf->data);
1201
1202 free(fparname);
1204 }
1205
1206 PQclear(res);
1207 fprintf(OPF, "\n\n");
1208}
1209
1210
1211/*
1212 * Drop tablespaces.
1213 */
1214static void
1216{
1217 PGresult *res;
1218 int i;
1219
1220 /*
1221 * Get all tablespaces except built-in ones (which we assume are named
1222 * pg_xxx)
1223 */
1224 res = executeQuery(conn, "SELECT spcname "
1225 "FROM pg_catalog.pg_tablespace "
1226 "WHERE spcname !~ '^pg_' "
1227 "ORDER BY 1");
1228
1229 if (PQntuples(res) > 0)
1230 fprintf(OPF, "--\n-- Drop tablespaces\n--\n\n");
1231
1232 for (i = 0; i < PQntuples(res); i++)
1233 {
1234 char *spcname = PQgetvalue(res, i, 0);
1235
1236 fprintf(OPF, "DROP TABLESPACE %s%s;\n",
1237 if_exists ? "IF EXISTS " : "",
1238 fmtId(spcname));
1239 }
1240
1241 PQclear(res);
1242
1243 fprintf(OPF, "\n\n");
1244}
1245
1246/*
1247 * Dump tablespaces.
1248 */
1249static void
1251{
1252 PGresult *res;
1253 int i;
1254
1255 /*
1256 * Get all tablespaces except built-in ones (which we assume are named
1257 * pg_xxx)
1258 */
1259 res = executeQuery(conn, "SELECT oid, spcname, "
1260 "pg_catalog.pg_get_userbyid(spcowner) AS spcowner, "
1261 "pg_catalog.pg_tablespace_location(oid), "
1262 "spcacl, acldefault('t', spcowner) AS acldefault, "
1263 "array_to_string(spcoptions, ', '),"
1264 "pg_catalog.shobj_description(oid, 'pg_tablespace') "
1265 "FROM pg_catalog.pg_tablespace "
1266 "WHERE spcname !~ '^pg_' "
1267 "ORDER BY 1");
1268
1269 if (PQntuples(res) > 0)
1270 fprintf(OPF, "--\n-- Tablespaces\n--\n\n");
1271
1272 for (i = 0; i < PQntuples(res); i++)
1273 {
1275 Oid spcoid = atooid(PQgetvalue(res, i, 0));
1276 char *spcname = PQgetvalue(res, i, 1);
1277 char *spcowner = PQgetvalue(res, i, 2);
1278 char *spclocation = PQgetvalue(res, i, 3);
1279 char *spcacl = PQgetvalue(res, i, 4);
1280 char *acldefault = PQgetvalue(res, i, 5);
1281 char *spcoptions = PQgetvalue(res, i, 6);
1282 char *spccomment = PQgetvalue(res, i, 7);
1283 char *fspcname;
1284
1285 /* needed for buildACLCommands() */
1286 fspcname = pg_strdup(fmtId(spcname));
1287
1288 if (binary_upgrade)
1289 {
1290 appendPQExpBufferStr(buf, "\n-- For binary upgrade, must preserve pg_tablespace oid\n");
1291 appendPQExpBuffer(buf, "SELECT pg_catalog.binary_upgrade_set_next_pg_tablespace_oid('%u'::pg_catalog.oid);\n", spcoid);
1292 }
1293
1294 appendPQExpBuffer(buf, "CREATE TABLESPACE %s", fspcname);
1295 appendPQExpBuffer(buf, " OWNER %s", fmtId(spcowner));
1296
1297 appendPQExpBufferStr(buf, " LOCATION ");
1298
1299 /*
1300 * In-place tablespaces use a relative path, and need to be dumped
1301 * with an empty string as location.
1302 */
1303 if (is_absolute_path(spclocation))
1304 appendStringLiteralConn(buf, spclocation, conn);
1305 else
1307
1308 appendPQExpBufferStr(buf, ";\n");
1309
1310 if (spcoptions && spcoptions[0] != '\0')
1311 appendPQExpBuffer(buf, "ALTER TABLESPACE %s SET (%s);\n",
1312 fspcname, spcoptions);
1313
1314 /* tablespaces can't have initprivs */
1315
1316 if (!skip_acls &&
1317 !buildACLCommands(fspcname, NULL, NULL, "TABLESPACE",
1318 spcacl, acldefault,
1319 spcowner, "", server_version, buf))
1320 {
1321 pg_log_error("could not parse ACL list (%s) for tablespace \"%s\"",
1322 spcacl, spcname);
1323 PQfinish(conn);
1324 exit_nicely(1);
1325 }
1326
1327 if (!no_comments && spccomment && spccomment[0] != '\0')
1328 {
1329 appendPQExpBuffer(buf, "COMMENT ON TABLESPACE %s IS ", fspcname);
1330 appendStringLiteralConn(buf, spccomment, conn);
1331 appendPQExpBufferStr(buf, ";\n");
1332 }
1333
1334 if (!no_security_labels)
1335 buildShSecLabels(conn, "pg_tablespace", spcoid,
1336 "TABLESPACE", spcname,
1337 buf);
1338
1339 fprintf(OPF, "%s", buf->data);
1340
1341 free(fspcname);
1343 }
1344
1345 PQclear(res);
1346 fprintf(OPF, "\n\n");
1347}
1348
1349
1350/*
1351 * Dump commands to drop each database.
1352 */
1353static void
1355{
1356 PGresult *res;
1357 int i;
1358
1359 /*
1360 * Skip databases marked not datallowconn, since we'd be unable to connect
1361 * to them anyway. This must agree with dumpDatabases().
1362 */
1364 "SELECT datname "
1365 "FROM pg_database d "
1366 "WHERE datallowconn AND datconnlimit != -2 "
1367 "ORDER BY datname");
1368
1369 if (PQntuples(res) > 0)
1370 fprintf(OPF, "--\n-- Drop databases (except postgres and template1)\n--\n\n");
1371
1372 for (i = 0; i < PQntuples(res); i++)
1373 {
1374 char *dbname = PQgetvalue(res, i, 0);
1375
1376 /*
1377 * Skip "postgres" and "template1"; dumpDatabases() will deal with
1378 * them specially. Also, be sure to skip "template0", even if for
1379 * some reason it's not marked !datallowconn.
1380 */
1381 if (strcmp(dbname, "template1") != 0 &&
1382 strcmp(dbname, "template0") != 0 &&
1383 strcmp(dbname, "postgres") != 0)
1384 {
1385 fprintf(OPF, "DROP DATABASE %s%s;\n",
1386 if_exists ? "IF EXISTS " : "",
1387 fmtId(dbname));
1388 }
1389 }
1390
1391 PQclear(res);
1392
1393 fprintf(OPF, "\n\n");
1394}
1395
1396
1397/*
1398 * Dump user-specific configuration
1399 */
1400static void
1402{
1404 PGresult *res;
1405
1406 printfPQExpBuffer(buf, "SELECT unnest(setconfig) FROM pg_db_role_setting "
1407 "WHERE setdatabase = 0 AND setrole = "
1408 "(SELECT oid FROM %s WHERE rolname = ",
1409 role_catalog);
1412
1413 res = executeQuery(conn, buf->data);
1414
1415 if (PQntuples(res) > 0)
1416 fprintf(OPF, "\n--\n-- User Config \"%s\"\n--\n\n", username);
1417
1418 for (int i = 0; i < PQntuples(res); i++)
1419 {
1422 "ROLE", username, NULL, NULL,
1423 buf);
1424 fprintf(OPF, "%s", buf->data);
1425 }
1426
1427 PQclear(res);
1428
1430}
1431
1432/*
1433 * Find a list of database names that match the given patterns.
1434 * See also expand_table_name_patterns() in pg_dump.c
1435 */
1436static void
1438 SimpleStringList *patterns,
1439 SimpleStringList *names)
1440{
1441 PQExpBuffer query;
1442 PGresult *res;
1443
1444 if (patterns->head == NULL)
1445 return; /* nothing to do */
1446
1447 query = createPQExpBuffer();
1448
1449 /*
1450 * The loop below runs multiple SELECTs, which might sometimes result in
1451 * duplicate entries in the name list, but we don't care, since all we're
1452 * going to do is test membership of the list.
1453 */
1454
1455 for (SimpleStringListCell *cell = patterns->head; cell; cell = cell->next)
1456 {
1457 int dotcnt;
1458
1460 "SELECT datname FROM pg_catalog.pg_database n\n");
1461 processSQLNamePattern(conn, query, cell->val, false,
1462 false, NULL, "datname", NULL, NULL, NULL,
1463 &dotcnt);
1464
1465 if (dotcnt > 0)
1466 {
1467 pg_log_error("improper qualified name (too many dotted names): %s",
1468 cell->val);
1469 PQfinish(conn);
1470 exit_nicely(1);
1471 }
1472
1473 res = executeQuery(conn, query->data);
1474 for (int i = 0; i < PQntuples(res); i++)
1475 {
1477 }
1478
1479 PQclear(res);
1480 resetPQExpBuffer(query);
1481 }
1482
1483 destroyPQExpBuffer(query);
1484}
1485
1486/*
1487 * Dump contents of databases.
1488 */
1489static void
1491{
1492 PGresult *res;
1493 int i;
1494
1495 /*
1496 * Skip databases marked not datallowconn, since we'd be unable to connect
1497 * to them anyway. This must agree with dropDBs().
1498 *
1499 * We arrange for template1 to be processed first, then we process other
1500 * DBs in alphabetical order. If we just did them all alphabetically, we
1501 * might find ourselves trying to drop the "postgres" database while still
1502 * connected to it. This makes trying to run the restore script while
1503 * connected to "template1" a bad idea, but there's no fixed order that
1504 * doesn't have some failure mode with --clean.
1505 */
1507 "SELECT datname "
1508 "FROM pg_database d "
1509 "WHERE datallowconn AND datconnlimit != -2 "
1510 "ORDER BY (datname <> 'template1'), datname");
1511
1512 if (PQntuples(res) > 0)
1513 fprintf(OPF, "--\n-- Databases\n--\n\n");
1514
1515 for (i = 0; i < PQntuples(res); i++)
1516 {
1517 char *dbname = PQgetvalue(res, i, 0);
1518 const char *create_opts;
1519 int ret;
1520
1521 /* Skip template0, even if it's not marked !datallowconn. */
1522 if (strcmp(dbname, "template0") == 0)
1523 continue;
1524
1525 /* Skip any explicitly excluded database */
1527 {
1528 pg_log_info("excluding database \"%s\"", dbname);
1529 continue;
1530 }
1531
1532 pg_log_info("dumping database \"%s\"", dbname);
1533
1534 fprintf(OPF, "--\n-- Database \"%s\" dump\n--\n\n", dbname);
1535
1536 /*
1537 * We assume that "template1" and "postgres" already exist in the
1538 * target installation. dropDBs() won't have removed them, for fear
1539 * of removing the DB the restore script is initially connected to. If
1540 * --clean was specified, tell pg_dump to drop and recreate them;
1541 * otherwise we'll merely restore their contents. Other databases
1542 * should simply be created.
1543 */
1544 if (strcmp(dbname, "template1") == 0 || strcmp(dbname, "postgres") == 0)
1545 {
1546 if (output_clean)
1547 create_opts = "--clean --create";
1548 else
1549 {
1550 create_opts = "";
1551 /* Since pg_dump won't emit a \connect command, we must */
1552 fprintf(OPF, "\\connect %s\n\n", dbname);
1553 }
1554 }
1555 else
1556 create_opts = "--create";
1557
1558 if (filename)
1559 fclose(OPF);
1560
1561 ret = runPgDump(dbname, create_opts);
1562 if (ret != 0)
1563 pg_fatal("pg_dump failed on database \"%s\", exiting", dbname);
1564
1565 if (filename)
1566 {
1567 OPF = fopen(filename, PG_BINARY_A);
1568 if (!OPF)
1569 pg_fatal("could not re-open the output file \"%s\": %m",
1570 filename);
1571 }
1572 }
1573
1574 PQclear(res);
1575}
1576
1577
1578
1579/*
1580 * Run pg_dump on dbname, with specified options.
1581 */
1582static int
1583runPgDump(const char *dbname, const char *create_opts)
1584{
1585 PQExpBufferData connstrbuf;
1586 PQExpBufferData cmd;
1587 int ret;
1588
1589 initPQExpBuffer(&connstrbuf);
1590 initPQExpBuffer(&cmd);
1591
1592 printfPQExpBuffer(&cmd, "\"%s\" %s %s", pg_dump_bin,
1593 pgdumpopts->data, create_opts);
1594
1595 /*
1596 * If we have a filename, use the undocumented plain-append pg_dump
1597 * format.
1598 */
1599 if (filename)
1600 appendPQExpBufferStr(&cmd, " -Fa ");
1601 else
1602 appendPQExpBufferStr(&cmd, " -Fp ");
1603
1604 /*
1605 * Append the database name to the already-constructed stem of connection
1606 * string.
1607 */
1608 appendPQExpBuffer(&connstrbuf, "%s dbname=", connstr);
1609 appendConnStrVal(&connstrbuf, dbname);
1610
1611 appendShellString(&cmd, connstrbuf.data);
1612
1613 pg_log_info("running \"%s\"", cmd.data);
1614
1615 fflush(NULL);
1616
1617 ret = system(cmd.data);
1618
1619 termPQExpBuffer(&cmd);
1620 termPQExpBuffer(&connstrbuf);
1621
1622 return ret;
1623}
1624
1625/*
1626 * buildShSecLabels
1627 *
1628 * Build SECURITY LABEL command(s) for a shared object
1629 *
1630 * The caller has to provide object type and identity in two separate formats:
1631 * catalog_name (e.g., "pg_database") and object OID, as well as
1632 * type name (e.g., "DATABASE") and object name (not pre-quoted).
1633 *
1634 * The command(s) are appended to "buffer".
1635 */
1636static void
1637buildShSecLabels(PGconn *conn, const char *catalog_name, Oid objectId,
1638 const char *objtype, const char *objname,
1639 PQExpBuffer buffer)
1640{
1642 PGresult *res;
1643
1644 buildShSecLabelQuery(catalog_name, objectId, sql);
1645 res = executeQuery(conn, sql->data);
1646 emitShSecLabels(conn, res, buffer, objtype, objname);
1647
1648 PQclear(res);
1649 destroyPQExpBuffer(sql);
1650}
1651
1652/*
1653 * Make a database connection with the given parameters. An
1654 * interactive password prompt is automatically issued if required.
1655 *
1656 * If fail_on_error is false, we return NULL without printing any message
1657 * on failure, but preserve any prompted password for the next try.
1658 *
1659 * On success, the global variable 'connstr' is set to a connection string
1660 * containing the options used.
1661 */
1662static PGconn *
1664 const char *pghost, const char *pgport, const char *pguser,
1665 trivalue prompt_password, bool fail_on_error)
1666{
1667 PGconn *conn;
1668 bool new_pass;
1669 const char *remoteversion_str;
1670 int my_version;
1671 const char **keywords = NULL;
1672 const char **values = NULL;
1673 PQconninfoOption *conn_opts = NULL;
1674 static char *password = NULL;
1675
1676 if (prompt_password == TRI_YES && !password)
1677 password = simple_prompt("Password: ", false);
1678
1679 /*
1680 * Start the connection. Loop until we have a password if requested by
1681 * backend.
1682 */
1683 do
1684 {
1685 int argcount = 6;
1686 PQconninfoOption *conn_opt;
1687 char *err_msg = NULL;
1688 int i = 0;
1689
1690 free(keywords);
1691 free(values);
1692 PQconninfoFree(conn_opts);
1693
1694 /*
1695 * Merge the connection info inputs given in form of connection string
1696 * and other options. Explicitly discard any dbname value in the
1697 * connection string; otherwise, PQconnectdbParams() would interpret
1698 * that value as being itself a connection string.
1699 */
1701 {
1702 conn_opts = PQconninfoParse(connection_string, &err_msg);
1703 if (conn_opts == NULL)
1704 pg_fatal("%s", err_msg);
1705
1706 for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
1707 {
1708 if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
1709 strcmp(conn_opt->keyword, "dbname") != 0)
1710 argcount++;
1711 }
1712
1713 keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
1714 values = pg_malloc0((argcount + 1) * sizeof(*values));
1715
1716 for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
1717 {
1718 if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
1719 strcmp(conn_opt->keyword, "dbname") != 0)
1720 {
1721 keywords[i] = conn_opt->keyword;
1722 values[i] = conn_opt->val;
1723 i++;
1724 }
1725 }
1726 }
1727 else
1728 {
1729 keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
1730 values = pg_malloc0((argcount + 1) * sizeof(*values));
1731 }
1732
1733 if (pghost)
1734 {
1735 keywords[i] = "host";
1736 values[i] = pghost;
1737 i++;
1738 }
1739 if (pgport)
1740 {
1741 keywords[i] = "port";
1742 values[i] = pgport;
1743 i++;
1744 }
1745 if (pguser)
1746 {
1747 keywords[i] = "user";
1748 values[i] = pguser;
1749 i++;
1750 }
1751 if (password)
1752 {
1753 keywords[i] = "password";
1754 values[i] = password;
1755 i++;
1756 }
1757 if (dbname)
1758 {
1759 keywords[i] = "dbname";
1760 values[i] = dbname;
1761 i++;
1762 }
1763 keywords[i] = "fallback_application_name";
1764 values[i] = progname;
1765 i++;
1766
1767 new_pass = false;
1769
1770 if (!conn)
1771 pg_fatal("could not connect to database \"%s\"", dbname);
1772
1773 if (PQstatus(conn) == CONNECTION_BAD &&
1775 !password &&
1776 prompt_password != TRI_NO)
1777 {
1778 PQfinish(conn);
1779 password = simple_prompt("Password: ", false);
1780 new_pass = true;
1781 }
1782 } while (new_pass);
1783
1784 /* check to see that the backend connection was successfully made */
1786 {
1787 if (fail_on_error)
1789 else
1790 {
1791 PQfinish(conn);
1792
1793 free(keywords);
1794 free(values);
1795 PQconninfoFree(conn_opts);
1796
1797 return NULL;
1798 }
1799 }
1800
1801 /*
1802 * Ok, connected successfully. Remember the options used, in the form of a
1803 * connection string.
1804 */
1806
1807 free(keywords);
1808 free(values);
1809 PQconninfoFree(conn_opts);
1810
1811 /* Check version */
1812 remoteversion_str = PQparameterStatus(conn, "server_version");
1813 if (!remoteversion_str)
1814 pg_fatal("could not get server version");
1816 if (server_version == 0)
1817 pg_fatal("could not parse server version \"%s\"",
1818 remoteversion_str);
1819
1820 my_version = PG_VERSION_NUM;
1821
1822 /*
1823 * We allow the server to be back to 9.2, and up to any minor release of
1824 * our own major version. (See also version check in pg_dump.c.)
1825 */
1826 if (my_version != server_version
1827 && (server_version < 90200 ||
1828 (server_version / 100) > (my_version / 100)))
1829 {
1830 pg_log_error("aborting because of server version mismatch");
1831 pg_log_error_detail("server version: %s; %s version: %s",
1832 remoteversion_str, progname, PG_VERSION);
1833 exit_nicely(1);
1834 }
1835
1837
1838 return conn;
1839}
1840
1841/* ----------
1842 * Construct a connection string from the given keyword/value pairs. It is
1843 * used to pass the connection options to the pg_dump subprocess.
1844 *
1845 * The following parameters are excluded:
1846 * dbname - varies in each pg_dump invocation
1847 * password - it's not secure to pass a password on the command line
1848 * fallback_application_name - we'll let pg_dump set it
1849 * ----------
1850 */
1851static char *
1852constructConnStr(const char **keywords, const char **values)
1853{
1855 char *connstr;
1856 int i;
1857 bool firstkeyword = true;
1858
1859 /* Construct a new connection string in key='value' format. */
1860 for (i = 0; keywords[i] != NULL; i++)
1861 {
1862 if (strcmp(keywords[i], "dbname") == 0 ||
1863 strcmp(keywords[i], "password") == 0 ||
1864 strcmp(keywords[i], "fallback_application_name") == 0)
1865 continue;
1866
1867 if (!firstkeyword)
1869 firstkeyword = false;
1870 appendPQExpBuffer(buf, "%s=", keywords[i]);
1872 }
1873
1874 connstr = pg_strdup(buf->data);
1876 return connstr;
1877}
1878
1879/*
1880 * Run a query, return the results, exit program on failure.
1881 */
1882static PGresult *
1883executeQuery(PGconn *conn, const char *query)
1884{
1885 PGresult *res;
1886
1887 pg_log_info("executing %s", query);
1888
1889 res = PQexec(conn, query);
1890 if (!res ||
1892 {
1893 pg_log_error("query failed: %s", PQerrorMessage(conn));
1894 pg_log_error_detail("Query was: %s", query);
1895 PQfinish(conn);
1896 exit_nicely(1);
1897 }
1898
1899 return res;
1900}
1901
1902/*
1903 * As above for a SQL command (which returns nothing).
1904 */
1905static void
1906executeCommand(PGconn *conn, const char *query)
1907{
1908 PGresult *res;
1909
1910 pg_log_info("executing %s", query);
1911
1912 res = PQexec(conn, query);
1913 if (!res ||
1915 {
1916 pg_log_error("query failed: %s", PQerrorMessage(conn));
1917 pg_log_error_detail("Query was: %s", query);
1918 PQfinish(conn);
1919 exit_nicely(1);
1920 }
1921
1922 PQclear(res);
1923}
1924
1925
1926/*
1927 * dumpTimestamp
1928 */
1929static void
1930dumpTimestamp(const char *msg)
1931{
1932 char buf[64];
1933 time_t now = time(NULL);
1934
1935 if (strftime(buf, sizeof(buf), PGDUMP_STRFTIME_FMT, localtime(&now)) != 0)
1936 fprintf(OPF, "-- %s %s\n\n", msg, buf);
1937}
1938
1939/*
1940 * read_dumpall_filters - retrieve database identifier patterns from file
1941 *
1942 * Parse the specified filter file for include and exclude patterns, and add
1943 * them to the relevant lists. If the filename is "-" then filters will be
1944 * read from STDIN rather than a file.
1945 *
1946 * At the moment, the only allowed filter is for database exclusion.
1947 */
1948static void
1950{
1951 FilterStateData fstate;
1952 char *objname;
1953 FilterCommandType comtype;
1954 FilterObjectType objtype;
1955
1956 filter_init(&fstate, filename, exit);
1957
1958 while (filter_read_item(&fstate, &objname, &comtype, &objtype))
1959 {
1960 if (comtype == FILTER_COMMAND_TYPE_INCLUDE)
1961 {
1962 pg_log_filter_error(&fstate, _("%s filter for \"%s\" is not allowed"),
1963 "include",
1964 filter_object_type_name(objtype));
1965 exit_nicely(1);
1966 }
1967
1968 switch (objtype)
1969 {
1971 break;
1982 pg_log_filter_error(&fstate, _("unsupported filter object"));
1983 exit_nicely(1);
1984 break;
1985
1987 simple_string_list_append(pattern, objname);
1988 break;
1989 }
1990
1991 if (objname)
1992 free(objname);
1993 }
1994
1995 filter_free(&fstate);
1996}
Acl * acldefault(ObjectType objtype, Oid ownerId)
Definition: acl.c:787
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1608
static Datum values[MAXATTR]
Definition: bootstrap.c:151
#define PG_BINARY_A
Definition: c.h:1228
#define PG_TEXTDOMAIN(domain)
Definition: c.h:1168
#define CppAsString2(x)
Definition: c.h:346
uint32_t uint32
Definition: c.h:485
#define PG_BINARY_W
Definition: c.h:1230
int find_my_exec(const char *argv0, char *retpath)
Definition: exec.c:160
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition: exec.c:429
int find_other_exec(const char *argv0, const char *target, const char *versionstr, char *retpath)
Definition: exec.c:310
#define ALWAYS_SECURE_SEARCH_PATH_SQL
Definition: connect.h:25
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
bool buildACLCommands(const char *name, const char *subname, const char *nspname, const char *type, const char *acls, const char *baseacls, const char *owner, const char *prefix, int remoteVersion, PQExpBuffer sql)
Definition: dumputils.c:64
void buildShSecLabelQuery(const char *catalog_name, Oid objectId, PQExpBuffer sql)
Definition: dumputils.c:637
void makeAlterConfigCommand(PGconn *conn, const char *configitem, const char *type, const char *name, const char *type2, const char *name2, PQExpBuffer buf)
Definition: dumputils.c:823
void emitShSecLabels(PGconn *conn, PGresult *res, PQExpBuffer buffer, const char *objtype, const char *objname)
Definition: dumputils.c:655
#define PGDUMP_STRFTIME_FMT
Definition: dumputils.h:33
#define _(x)
Definition: elog.c:90
void fsync_fname(const char *fname, bool isdir)
Definition: fd.c:755
int PQserverVersion(const PGconn *conn)
Definition: fe-connect.c:7199
void PQconninfoFree(PQconninfoOption *connOptions)
Definition: fe-connect.c:7024
PQconninfoOption * PQconninfoParse(const char *conninfo, char **errmsg)
Definition: fe-connect.c:5740
const char * PQparameterStatus(const PGconn *conn, const char *paramName)
Definition: fe-connect.c:7164
int PQconnectionNeedsPassword(const PGconn *conn)
Definition: fe-connect.c:7260
ConnStatusType PQstatus(const PGconn *conn)
Definition: fe-connect.c:7146
int PQclientEncoding(const PGconn *conn)
Definition: fe-connect.c:7297
void PQfinish(PGconn *conn)
Definition: fe-connect.c:4880
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:7209
int PQsetClientEncoding(PGconn *conn, const char *encoding)
Definition: fe-connect.c:7305
PGconn * PQconnectdbParams(const char *const *keywords, const char *const *values, int expand_dbname)
Definition: fe-connect.c:691
char * PQgetvalue(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3876
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:3411
int PQntuples(const PGresult *res)
Definition: fe-exec.c:3481
int PQfnumber(const PGresult *res, const char *field_name)
Definition: fe-exec.c:3589
int PQgetisnull(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3901
PGresult * PQexec(PGconn *conn, const char *query)
Definition: fe-exec.c:2262
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
void pg_free(void *ptr)
Definition: fe_memutils.c:105
void filter_init(FilterStateData *fstate, const char *filename, exit_function f_exit)
Definition: filter.c:36
void filter_free(FilterStateData *fstate)
Definition: filter.c:60
const char * filter_object_type_name(FilterObjectType fot)
Definition: filter.c:82
bool filter_read_item(FilterStateData *fstate, char **objname, FilterCommandType *comtype, FilterObjectType *objtype)
Definition: filter.c:389
void pg_log_filter_error(FilterStateData *fstate, const char *fmt,...)
Definition: filter.c:154
FilterObjectType
Definition: filter.h:48
@ FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN
Definition: filter.h:51
@ FILTER_OBJECT_TYPE_SCHEMA
Definition: filter.h:57
@ FILTER_OBJECT_TYPE_INDEX
Definition: filter.h:56
@ FILTER_OBJECT_TYPE_TRIGGER
Definition: filter.h:60
@ FILTER_OBJECT_TYPE_FOREIGN_DATA
Definition: filter.h:54
@ FILTER_OBJECT_TYPE_DATABASE
Definition: filter.h:52
@ FILTER_OBJECT_TYPE_FUNCTION
Definition: filter.h:55
@ FILTER_OBJECT_TYPE_TABLE_DATA
Definition: filter.h:50
@ FILTER_OBJECT_TYPE_NONE
Definition: filter.h:49
@ FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN
Definition: filter.h:59
@ FILTER_OBJECT_TYPE_EXTENSION
Definition: filter.h:53
@ FILTER_OBJECT_TYPE_TABLE
Definition: filter.h:58
FilterCommandType
Definition: filter.h:38
@ FILTER_COMMAND_TYPE_INCLUDE
Definition: filter.h:40
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition: getopt_long.c:60
#define no_argument
Definition: getopt_long.h:24
#define required_argument
Definition: getopt_long.h:25
return str start
#define free(a)
Definition: header.h:65
int remaining
Definition: informix.c:692
static char * username
Definition: initdb.c:153
int i
Definition: isn.c:72
static const JsonPathKeyword keywords[]
@ CONNECTION_BAD
Definition: libpq-fe.h:82
@ PGRES_COMMAND_OK
Definition: libpq-fe.h:120
@ PGRES_TUPLES_OK
Definition: libpq-fe.h:123
static void const char fflush(stdout)
exit(1)
void pg_logging_increase_verbosity(void)
Definition: logging.c:185
void pg_logging_init(const char *argv0)
Definition: logging.c:83
void pg_logging_set_level(enum pg_log_level new_level)
Definition: logging.c:176
#define pg_log_error(...)
Definition: logging.h:106
#define pg_log_error_hint(...)
Definition: logging.h:112
#define pg_log_info(...)
Definition: logging.h:124
@ PG_LOG_WARNING
Definition: logging.h:38
#define pg_log_error_detail(...)
Definition: logging.h:109
bool set_option
bool inherit_option
bool admin_option
#define pg_fatal(...)
#define MAXPGPATH
int32 encoding
Definition: pg_database.h:41
static void dumpTimestamp(const char *msg)
Definition: pg_dumpall.c:1930
static int if_exists
Definition: pg_dumpall.c:98
static int on_conflict_do_nothing
Definition: pg_dumpall.c:112
int main(int argc, char *argv[])
Definition: pg_dumpall.c:127
static void dropTablespaces(PGconn *conn)
Definition: pg_dumpall.c:1215
static void expand_dbname_patterns(PGconn *conn, SimpleStringList *patterns, SimpleStringList *names)
Definition: pg_dumpall.c:1437
static int no_role_passwords
Definition: pg_dumpall.c:109
static PQExpBuffer pgdumpopts
Definition: pg_dumpall.c:87
static int no_table_access_method
Definition: pg_dumpall.c:100
static int no_unlogged_table_data
Definition: pg_dumpall.c:108
#define PG_AUTHID
Definition: pg_dumpall.c:115
static int binary_upgrade
Definition: pg_dumpall.c:94
static int disable_triggers
Definition: pg_dumpall.c:97
static void dumpUserConfig(PGconn *conn, const char *username)
Definition: pg_dumpall.c:1401
static bool dosync
Definition: pg_dumpall.c:92
static char * connstr
Definition: pg_dumpall.c:88
static SimpleStringList database_exclude_patterns
Definition: pg_dumpall.c:121
static void dumpTablespaces(PGconn *conn)
Definition: pg_dumpall.c:1250
static void dumpRoleMembership(PGconn *conn)
Definition: pg_dumpall.c:958
static PGconn * connectDatabase(const char *dbname, const char *connection_string, const char *pghost, const char *pgport, const char *pguser, trivalue prompt_password, bool fail_on_error)
Definition: pg_dumpall.c:1663
#define exit_nicely(code)
Definition: pg_dumpall.c:124
static char pg_dump_bin[MAXPGPATH]
Definition: pg_dumpall.c:85
static SimpleStringList database_exclude_names
Definition: pg_dumpall.c:122
static FILE * OPF
Definition: pg_dumpall.c:118
static int no_comments
Definition: pg_dumpall.c:103
static char * constructConnStr(const char **keywords, const char **values)
Definition: pg_dumpall.c:1852
static int no_publications
Definition: pg_dumpall.c:104
static int no_security_labels
Definition: pg_dumpall.c:105
static void dumpDatabases(PGconn *conn)
Definition: pg_dumpall.c:1490
static int disable_dollar_quoting
Definition: pg_dumpall.c:96
static void buildShSecLabels(PGconn *conn, const char *catalog_name, Oid objectId, const char *objtype, const char *objname, PQExpBuffer buffer)
Definition: pg_dumpall.c:1637
static int no_tablespaces
Definition: pg_dumpall.c:101
static int no_toast_compression
Definition: pg_dumpall.c:107
#define PG_ROLES
Definition: pg_dumpall.c:116
static int inserts
Definition: pg_dumpall.c:99
static void executeCommand(PGconn *conn, const char *query)
Definition: pg_dumpall.c:1906
static bool verbose
Definition: pg_dumpall.c:91
static int runPgDump(const char *dbname, const char *create_opts)
Definition: pg_dumpall.c:1583
static void dumpRoleGUCPrivs(PGconn *conn)
Definition: pg_dumpall.c:1160
static void dumpRoles(PGconn *conn)
Definition: pg_dumpall.c:750
static PGresult * executeQuery(PGconn *conn, const char *query)
Definition: pg_dumpall.c:1883
static void help(void)
Definition: pg_dumpall.c:632
static int use_setsessauth
Definition: pg_dumpall.c:102
static int load_via_partition_root
Definition: pg_dumpall.c:111
static int column_inserts
Definition: pg_dumpall.c:95
static void read_dumpall_filters(const char *filename, SimpleStringList *pattern)
Definition: pg_dumpall.c:1949
static void dropRoles(PGconn *conn)
Definition: pg_dumpall.c:703
static void dropDBs(PGconn *conn)
Definition: pg_dumpall.c:1354
static int server_version
Definition: pg_dumpall.c:110
static char role_catalog[10]
Definition: pg_dumpall.c:114
static const char * progname
Definition: pg_dumpall.c:86
static bool output_clean
Definition: pg_dumpall.c:89
static int no_subscriptions
Definition: pg_dumpall.c:106
static char * filename
Definition: pg_dumpall.c:119
#define PGDUMP_VERSIONSTR
Definition: pg_dumpall.c:34
static bool skip_acls
Definition: pg_dumpall.c:90
PGDLLIMPORT int optind
Definition: getopt.c:51
PGDLLIMPORT char * optarg
Definition: getopt.c:53
static char * buf
Definition: pg_test_fsync.c:72
#define pg_encoding_to_char
Definition: pg_wchar.h:630
static const char * pghost
Definition: pgbench.c:294
static const char * pgport
Definition: pgbench.c:295
#define pg_log_warning(...)
Definition: pgfnames.c:24
#define is_absolute_path(filename)
Definition: port.h:103
#define sprintf
Definition: port.h:240
const char * get_progname(const char *argv0)
Definition: path.c:575
#define printf(...)
Definition: port.h:244
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
unsigned int Oid
Definition: postgres_ext.h:31
#define atooid(x)
Definition: postgres_ext.h:42
void printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:235
PQExpBuffer createPQExpBuffer(void)
Definition: pqexpbuffer.c:72
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:90
void resetPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:146
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:265
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:114
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:378
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:367
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:129
char * c
bool quote_all_identifiers
Definition: ruleutils.c:337
bool simple_string_list_member(SimpleStringList *list, const char *val)
Definition: simple_list.c:87
void simple_string_list_append(SimpleStringList *list, const char *val)
Definition: simple_list.c:63
char * simple_prompt(const char *prompt, bool echo)
Definition: sprompt.c:38
static char * password
Definition: streamutil.c:52
char * connection_string
Definition: streamutil.c:46
char * dbname
Definition: streamutil.c:50
PGconn * conn
Definition: streamutil.c:53
const char * fmtId(const char *rawid)
Definition: string_utils.c:64
void appendShellString(PQExpBuffer buf, const char *str)
Definition: string_utils.c:429
void appendStringLiteralConn(PQExpBuffer buf, const char *str, PGconn *conn)
Definition: string_utils.c:293
bool processSQLNamePattern(PGconn *conn, PQExpBuffer buf, const char *pattern, bool have_where, bool force_escape, const char *schemavar, const char *namevar, const char *altnamevar, const char *visibilityrule, PQExpBuffer dbnamebuf, int *dotcnt)
Definition: string_utils.c:891
void appendConnStrVal(PQExpBuffer buf, const char *str)
Definition: string_utils.c:545
uint32 hashval
Definition: pg_dumpall.c:39
uint32 status
Definition: pg_dumpall.c:38
char * rolename
Definition: pg_dumpall.c:40
struct SimpleStringListCell * next
Definition: simple_list.h:34
SimpleStringListCell * head
Definition: simple_list.h:42
trivalue
Definition: vacuumlo.c:35
@ TRI_YES
Definition: vacuumlo.c:38
@ TRI_DEFAULT
Definition: vacuumlo.c:36
@ TRI_NO
Definition: vacuumlo.c:37