PostgreSQL Source Code  git master
pg_backup_archiver.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pg_backup_archiver.c
4  *
5  * Private implementation of the archiver routines.
6  *
7  * See the headers to pg_restore for more details.
8  *
9  * Copyright (c) 2000, Philip Warner
10  * Rights are granted to use this software in any way so long
11  * as this notice is not removed.
12  *
13  * The author is not responsible for loss or damages that may
14  * result from its use.
15  *
16  *
17  * IDENTIFICATION
18  * src/bin/pg_dump/pg_backup_archiver.c
19  *
20  *-------------------------------------------------------------------------
21  */
22 #include "postgres_fe.h"
23 
24 #include <ctype.h>
25 #include <fcntl.h>
26 #include <unistd.h>
27 #include <sys/stat.h>
28 #include <sys/wait.h>
29 #ifdef WIN32
30 #include <io.h>
31 #endif
32 
33 #include "common/string.h"
34 #include "compress_io.h"
35 #include "dumputils.h"
36 #include "fe_utils/string_utils.h"
37 #include "lib/binaryheap.h"
38 #include "lib/stringinfo.h"
39 #include "libpq/libpq-fs.h"
40 #include "parallel.h"
41 #include "pg_backup_archiver.h"
42 #include "pg_backup_db.h"
43 #include "pg_backup_utils.h"
44 
45 #define TEXT_DUMP_HEADER "--\n-- PostgreSQL database dump\n--\n\n"
46 #define TEXT_DUMPALL_HEADER "--\n-- PostgreSQL database cluster dump\n--\n\n"
47 
48 
49 static ArchiveHandle *_allocAH(const char *FileSpec, const ArchiveFormat fmt,
50  const pg_compress_specification compression_spec,
51  bool dosync, ArchiveMode mode,
52  SetupWorkerPtrType setupWorkerPtr,
53  DataDirSyncMethod sync_method);
54 static void _getObjectDescription(PQExpBuffer buf, const TocEntry *te);
55 static void _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData);
56 static char *sanitize_line(const char *str, bool want_hyphen);
57 static void _doSetFixedOutputState(ArchiveHandle *AH);
58 static void _doSetSessionAuth(ArchiveHandle *AH, const char *user);
59 static void _reconnectToDB(ArchiveHandle *AH, const char *dbname);
60 static void _becomeUser(ArchiveHandle *AH, const char *user);
61 static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);
62 static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);
63 static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);
64 static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tableam);
65 static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);
66 static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);
67 static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);
68 static int _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH);
69 static RestorePass _tocEntryRestorePass(TocEntry *te);
70 static bool _tocEntryIsACL(TocEntry *te);
71 static void _disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te);
72 static void _enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te);
73 static bool is_load_via_partition_root(TocEntry *te);
74 static void buildTocEntryArrays(ArchiveHandle *AH);
75 static void _moveBefore(TocEntry *pos, TocEntry *te);
76 static int _discoverArchiveFormat(ArchiveHandle *AH);
77 
78 static int RestoringToDB(ArchiveHandle *AH);
79 static void dump_lo_buf(ArchiveHandle *AH);
80 static void dumpTimestamp(ArchiveHandle *AH, const char *msg, time_t tim);
81 static void SetOutput(ArchiveHandle *AH, const char *filename,
82  const pg_compress_specification compression_spec);
83 static CompressFileHandle *SaveOutput(ArchiveHandle *AH);
84 static void RestoreOutput(ArchiveHandle *AH, CompressFileHandle *savedOutput);
85 
86 static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel);
87 static void restore_toc_entries_prefork(ArchiveHandle *AH,
88  TocEntry *pending_list);
89 static void restore_toc_entries_parallel(ArchiveHandle *AH,
90  ParallelState *pstate,
91  TocEntry *pending_list);
92 static void restore_toc_entries_postfork(ArchiveHandle *AH,
93  TocEntry *pending_list);
94 static void pending_list_header_init(TocEntry *l);
95 static void pending_list_append(TocEntry *l, TocEntry *te);
96 static void pending_list_remove(TocEntry *te);
97 static int TocEntrySizeCompareQsort(const void *p1, const void *p2);
98 static int TocEntrySizeCompareBinaryheap(void *p1, void *p2, void *arg);
99 static void move_to_ready_heap(TocEntry *pending_list,
100  binaryheap *ready_heap,
101  RestorePass pass);
102 static TocEntry *pop_next_work_item(binaryheap *ready_heap,
103  ParallelState *pstate);
104 static void mark_dump_job_done(ArchiveHandle *AH,
105  TocEntry *te,
106  int status,
107  void *callback_data);
108 static void mark_restore_job_done(ArchiveHandle *AH,
109  TocEntry *te,
110  int status,
111  void *callback_data);
112 static void fix_dependencies(ArchiveHandle *AH);
113 static bool has_lock_conflicts(TocEntry *te1, TocEntry *te2);
114 static void repoint_table_dependencies(ArchiveHandle *AH);
115 static void identify_locking_dependencies(ArchiveHandle *AH, TocEntry *te);
116 static void reduce_dependencies(ArchiveHandle *AH, TocEntry *te,
117  binaryheap *ready_heap);
118 static void mark_create_done(ArchiveHandle *AH, TocEntry *te);
119 static void inhibit_data_for_failed_table(ArchiveHandle *AH, TocEntry *te);
120 
121 static void StrictNamesCheck(RestoreOptions *ropt);
122 
123 
124 /*
125  * Allocate a new DumpOptions block containing all default values.
126  */
127 DumpOptions *
128 NewDumpOptions(void)
129 {
130  DumpOptions *opts = (DumpOptions *) pg_malloc(sizeof(DumpOptions));
131 
132  InitDumpOptions(opts);
133  return opts;
134 }
135 
136 /*
137  * Initialize a DumpOptions struct to all default values
138  */
139 void
140 InitDumpOptions(DumpOptions *opts)
141 {
142  memset(opts, 0, sizeof(DumpOptions));
143  /* set any fields that shouldn't default to zeroes */
144  opts->include_everything = true;
145  opts->cparams.promptPassword = TRI_DEFAULT;
146  opts->dumpSections = DUMP_UNSECTIONED;
147 }
148 
149 /*
150  * Create a freshly allocated DumpOptions with options equivalent to those
151  * found in the given RestoreOptions.
152  */
153 DumpOptions *
154 dumpOptionsFromRestoreOptions(RestoreOptions *ropt)
155 {
156  DumpOptions *dopt = NewDumpOptions();
157 
158  /* this is the inverse of what's at the end of pg_dump.c's main() */
159  dopt->cparams.dbname = ropt->cparams.dbname ? pg_strdup(ropt->cparams.dbname) : NULL;
160  dopt->cparams.pgport = ropt->cparams.pgport ? pg_strdup(ropt->cparams.pgport) : NULL;
161  dopt->cparams.pghost = ropt->cparams.pghost ? pg_strdup(ropt->cparams.pghost) : NULL;
162  dopt->cparams.username = ropt->cparams.username ? pg_strdup(ropt->cparams.username) : NULL;
163  dopt->cparams.promptPassword = ropt->cparams.promptPassword;
164  dopt->outputClean = ropt->dropSchema;
165  dopt->dataOnly = ropt->dataOnly;
166  dopt->schemaOnly = ropt->schemaOnly;
167  dopt->if_exists = ropt->if_exists;
168  dopt->column_inserts = ropt->column_inserts;
169  dopt->dumpSections = ropt->dumpSections;
170  dopt->aclsSkip = ropt->aclsSkip;
171  dopt->outputSuperuser = ropt->superuser;
172  dopt->outputCreateDB = ropt->createDB;
173  dopt->outputNoOwner = ropt->noOwner;
174  dopt->outputNoTableAm = ropt->noTableAm;
175  dopt->outputNoTablespaces = ropt->noTablespace;
176  dopt->disable_triggers = ropt->disable_triggers;
177  dopt->use_setsessauth = ropt->use_setsessauth;
178  dopt->disable_dollar_quoting = ropt->disable_dollar_quoting;
179  dopt->dump_inserts = ropt->dump_inserts;
180  dopt->no_comments = ropt->no_comments;
181  dopt->no_publications = ropt->no_publications;
182  dopt->no_security_labels = ropt->no_security_labels;
183  dopt->no_subscriptions = ropt->no_subscriptions;
184  dopt->lockWaitTimeout = ropt->lockWaitTimeout;
185  dopt->include_everything = ropt->include_everything;
186  dopt->enable_row_security = ropt->enable_row_security;
187  dopt->sequence_data = ropt->sequence_data;
188 
189  return dopt;
190 }
191 
192 
193 /*
194  * Wrapper functions.
195  *
196  * The objective is to make writing new formats and dumpers as simple
197  * as possible, if necessary at the expense of extra function calls etc.
198  *
199  */
200 
201 /*
202  * The dump worker setup needs lots of knowledge of the internals of pg_dump,
203  * so it's defined in pg_dump.c and passed into OpenArchive. The restore worker
204  * setup doesn't need to know anything much, so it's defined here.
205  */
206 static void
207 setupRestoreWorker(Archive *AHX)
208 {
209  ArchiveHandle *AH = (ArchiveHandle *) AHX;
210 
211  AH->ReopenPtr(AH);
212 }
213 
214 
215 /* Create a new archive */
216 /* Public */
217 Archive *
218 CreateArchive(const char *FileSpec, const ArchiveFormat fmt,
219  const pg_compress_specification compression_spec,
220  bool dosync, ArchiveMode mode,
221  SetupWorkerPtrType setupDumpWorker,
222  DataDirSyncMethod sync_method)
223 
224 {
225  ArchiveHandle *AH = _allocAH(FileSpec, fmt, compression_spec,
226  dosync, mode, setupDumpWorker, sync_method);
227 
228  return (Archive *) AH;
229 }
230 
231 /* Open an existing archive */
232 /* Public */
233 Archive *
234 OpenArchive(const char *FileSpec, const ArchiveFormat fmt)
235 {
236  ArchiveHandle *AH;
237  pg_compress_specification compression_spec = {0};
238 
239  compression_spec.algorithm = PG_COMPRESSION_NONE;
240  AH = _allocAH(FileSpec, fmt, compression_spec, true,
241  archModeRead, setupRestoreWorker,
242  DATA_DIR_SYNC_METHOD_FSYNC);
243 
244  return (Archive *) AH;
245 }
246 
247 /* Public */
248 void
249 CloseArchive(Archive *AHX)
250 {
251  ArchiveHandle *AH = (ArchiveHandle *) AHX;
252 
253  AH->ClosePtr(AH);
254 
255  /* Close the output */
256  errno = 0;
257  if (!EndCompressFileHandle(AH->OF))
258  pg_fatal("could not close output file: %m");
259 }
260 
261 /* Public */
262 void
263 SetArchiveOptions(Archive *AH, DumpOptions *dopt, RestoreOptions *ropt)
264 {
265  /* Caller can omit dump options, in which case we synthesize them */
266  if (dopt == NULL && ropt != NULL)
267  dopt = dumpOptionsFromRestoreOptions(ropt);
268 
269  /* Save options for later access */
270  AH->dopt = dopt;
271  AH->ropt = ropt;
272 }
273 
274 /* Public */
275 void
276 ProcessArchiveRestoreOptions(Archive *AHX)
277 {
278  ArchiveHandle *AH = (ArchiveHandle *) AHX;
279  RestoreOptions *ropt = AH->public.ropt;
280  TocEntry *te;
281  teSection curSection;
282 
283  /* Decide which TOC entries will be dumped/restored, and mark them */
284  curSection = SECTION_PRE_DATA;
285  for (te = AH->toc->next; te != AH->toc; te = te->next)
286  {
287  /*
288  * When writing an archive, we also take this opportunity to check
289  * that we have generated the entries in a sane order that respects
290  * the section divisions. When reading, don't complain, since buggy
291  * old versions of pg_dump might generate out-of-order archives.
292  */
293  if (AH->mode != archModeRead)
294  {
295  switch (te->section)
296  {
297  case SECTION_NONE:
298  /* ok to be anywhere */
299  break;
300  case SECTION_PRE_DATA:
301  if (curSection != SECTION_PRE_DATA)
302  pg_log_warning("archive items not in correct section order");
303  break;
304  case SECTION_DATA:
305  if (curSection == SECTION_POST_DATA)
306  pg_log_warning("archive items not in correct section order");
307  break;
308  case SECTION_POST_DATA:
309  /* ok no matter which section we were in */
310  break;
311  default:
312  pg_fatal("unexpected section code %d",
313  (int) te->section);
314  break;
315  }
316  }
317 
318  if (te->section != SECTION_NONE)
319  curSection = te->section;
320 
321  te->reqs = _tocEntryRequired(te, curSection, AH);
322  }
323 
324  /* Enforce strict names checking */
325  if (ropt->strict_names)
326  StrictNamesCheck(ropt);
327 }
328 
329 /* Public */
330 void
331 RestoreArchive(Archive *AHX)
332 {
333  ArchiveHandle *AH = (ArchiveHandle *) AHX;
334  RestoreOptions *ropt = AH->public.ropt;
335  bool parallel_mode;
336  TocEntry *te;
337  CompressFileHandle *sav;
338 
339  AH->stage = STAGE_INITIALIZING;
340 
341  /*
342  * If we're going to do parallel restore, there are some restrictions.
343  */
344  parallel_mode = (AH->public.numWorkers > 1 && ropt->useDB);
345  if (parallel_mode)
346  {
347  /* We haven't got round to making this work for all archive formats */
348  if (AH->ClonePtr == NULL || AH->ReopenPtr == NULL)
349  pg_fatal("parallel restore is not supported with this archive file format");
350 
351  /* Doesn't work if the archive represents dependencies as OIDs */
352  if (AH->version < K_VERS_1_8)
353  pg_fatal("parallel restore is not supported with archives made by pre-8.0 pg_dump");
354 
355  /*
356  * It's also not gonna work if we can't reopen the input file, so
357  * let's try that immediately.
358  */
359  AH->ReopenPtr(AH);
360  }
361 
362  /*
363  * Make sure we won't need (de)compression we haven't got
364  */
365  if (AH->PrintTocDataPtr != NULL)
366  {
367  for (te = AH->toc->next; te != AH->toc; te = te->next)
368  {
369  if (te->hadDumper && (te->reqs & REQ_DATA) != 0)
370  {
371  char *errmsg = supports_compression(AH->compression_spec);
372 
373  if (errmsg)
374  pg_fatal("cannot restore from compressed archive (%s)",
375  errmsg);
376  else
377  break;
378  }
379  }
380  }
381 
382  /*
383  * Prepare index arrays, so we can assume we have them throughout restore.
384  * It's possible we already did this, though.
385  */
386  if (AH->tocsByDumpId == NULL)
387  buildTocEntryArrays(AH);
388 
389  /*
390  * If we're using a DB connection, then connect it.
391  */
392  if (ropt->useDB)
393  {
394  pg_log_info("connecting to database for restore");
395  if (AH->version < K_VERS_1_3)
396  pg_fatal("direct database connections are not supported in pre-1.3 archives");
397 
398  /*
399  * We don't want to guess at whether the dump will successfully
400  * restore; allow the attempt regardless of the version of the restore
401  * target.
402  */
403  AHX->minRemoteVersion = 0;
404  AHX->maxRemoteVersion = 9999999;
405 
406  ConnectDatabase(AHX, &ropt->cparams, false);
407 
408  /*
409  * If we're talking to the DB directly, don't send comments since they
410  * obscure SQL when displaying errors
411  */
412  AH->noTocComments = 1;
413  }
414 
415  /*
416  * Work out if we have an implied data-only restore. This can happen if
417  * the dump was data only or if the user has used a toc list to exclude
418  * all of the schema data. All we do is look for schema entries - if none
419  * are found then we set the dataOnly flag.
420  *
421  * We could scan for wanted TABLE entries, but that is not the same as
422  * dataOnly. At this stage, it seems unnecessary (6-Mar-2001).
423  */
424  if (!ropt->dataOnly)
425  {
426  int impliedDataOnly = 1;
427 
428  for (te = AH->toc->next; te != AH->toc; te = te->next)
429  {
430  if ((te->reqs & REQ_SCHEMA) != 0)
431  { /* It's schema, and it's wanted */
432  impliedDataOnly = 0;
433  break;
434  }
435  }
436  if (impliedDataOnly)
437  {
438  ropt->dataOnly = impliedDataOnly;
439  pg_log_info("implied data-only restore");
440  }
441  }
442 
443  /*
444  * Setup the output file if necessary.
445  */
446  sav = SaveOutput(AH);
447  if (ropt->filename || ropt->compression_spec.algorithm != PG_COMPRESSION_NONE)
448  SetOutput(AH, ropt->filename, ropt->compression_spec);
449 
450  ahprintf(AH, "--\n-- PostgreSQL database dump\n--\n\n");
451 
452  if (AH->archiveRemoteVersion)
453  ahprintf(AH, "-- Dumped from database version %s\n",
454  AH->archiveRemoteVersion);
455  if (AH->archiveDumpVersion)
456  ahprintf(AH, "-- Dumped by pg_dump version %s\n",
457  AH->archiveDumpVersion);
458 
459  ahprintf(AH, "\n");
460 
461  if (AH->public.verbose)
462  dumpTimestamp(AH, "Started on", AH->createDate);
463 
464  if (ropt->single_txn)
465  {
466  if (AH->connection)
467  StartTransaction(AHX);
468  else
469  ahprintf(AH, "BEGIN;\n\n");
470  }
471 
472  /*
473  * Establish important parameter values right away.
474  */
475  _doSetFixedOutputState(AH);
476 
477  AH->stage = STAGE_PROCESSING;
478 
479  /*
480  * Drop the items at the start, in reverse order
481  */
482  if (ropt->dropSchema)
483  {
484  for (te = AH->toc->prev; te != AH->toc; te = te->prev)
485  {
486  AH->currentTE = te;
487 
488  /*
489  * In createDB mode, issue a DROP *only* for the database as a
490  * whole. Issuing drops against anything else would be wrong,
491  * because at this point we're connected to the wrong database.
492  * (The DATABASE PROPERTIES entry, if any, should be treated like
493  * the DATABASE entry.)
494  */
495  if (ropt->createDB)
496  {
497  if (strcmp(te->desc, "DATABASE") != 0 &&
498  strcmp(te->desc, "DATABASE PROPERTIES") != 0)
499  continue;
500  }
501 
502  /* Otherwise, drop anything that's selected and has a dropStmt */
503  if (((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0) && te->dropStmt)
504  {
505  pg_log_info("dropping %s %s", te->desc, te->tag);
506  /* Select owner and schema as necessary */
507  _becomeOwner(AH, te);
508  _selectOutputSchema(AH, te->namespace);
509 
510  /*
511  * Now emit the DROP command, if the object has one. Note we
512  * don't necessarily emit it verbatim; at this point we add an
513  * appropriate IF EXISTS clause, if the user requested it.
514  */
515  if (*te->dropStmt != '\0')
516  {
517  if (!ropt->if_exists ||
518  strncmp(te->dropStmt, "--", 2) == 0)
519  {
520  /*
521  * Without --if-exists, or if it's just a comment (as
522  * happens for the public schema), print the dropStmt
523  * as-is.
524  */
525  ahprintf(AH, "%s", te->dropStmt);
526  }
527  else
528  {
529  /*
530  * Inject an appropriate spelling of "if exists". For
531  * large objects, we have a separate routine that
532  * knows how to do it, without depending on
533  * te->dropStmt; use that. For other objects we need
534  * to parse the command.
535  */
536  if (strncmp(te->desc, "BLOB", 4) == 0)
537  {
538  DropLOIfExists(AH, te->catalogId.oid);
539  }
540  else
541  {
542  char *dropStmt = pg_strdup(te->dropStmt);
543  char *dropStmtOrig = dropStmt;
544  PQExpBuffer ftStmt = createPQExpBuffer();
545 
546  /*
547  * Need to inject IF EXISTS clause after ALTER
548  * TABLE part in ALTER TABLE .. DROP statement
549  */
550  if (strncmp(dropStmt, "ALTER TABLE", 11) == 0)
551  {
552  appendPQExpBufferStr(ftStmt,
553  "ALTER TABLE IF EXISTS");
554  dropStmt = dropStmt + 11;
555  }
556 
557  /*
558  * ALTER TABLE..ALTER COLUMN..DROP DEFAULT does
559  * not support the IF EXISTS clause, and therefore
560  * we simply emit the original command for DEFAULT
561  * objects (modulo the adjustment made above).
562  *
563  * Likewise, don't mess with DATABASE PROPERTIES.
564  *
565  * If we used CREATE OR REPLACE VIEW as a means of
566  * quasi-dropping an ON SELECT rule, that should
567  * be emitted unchanged as well.
568  *
569  * For other object types, we need to extract the
570  * first part of the DROP which includes the
571  * object type. Most of the time this matches
572  * te->desc, so search for that; however for the
573  * different kinds of CONSTRAINTs, we know to
574  * search for hardcoded "DROP CONSTRAINT" instead.
575  */
576  if (strcmp(te->desc, "DEFAULT") == 0 ||
577  strcmp(te->desc, "DATABASE PROPERTIES") == 0 ||
578  strncmp(dropStmt, "CREATE OR REPLACE VIEW", 22) == 0)
579  appendPQExpBufferStr(ftStmt, dropStmt);
580  else
581  {
582  char buffer[40];
583  char *mark;
584 
585  if (strcmp(te->desc, "CONSTRAINT") == 0 ||
586  strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
587  strcmp(te->desc, "FK CONSTRAINT") == 0)
588  strcpy(buffer, "DROP CONSTRAINT");
589  else
590  snprintf(buffer, sizeof(buffer), "DROP %s",
591  te->desc);
592 
593  mark = strstr(dropStmt, buffer);
594 
595  if (mark)
596  {
597  *mark = '\0';
598  appendPQExpBuffer(ftStmt, "%s%s IF EXISTS%s",
599  dropStmt, buffer,
600  mark + strlen(buffer));
601  }
602  else
603  {
604  /* complain and emit unmodified command */
605  pg_log_warning("could not find where to insert IF EXISTS in statement \"%s\"",
606  dropStmtOrig);
607  appendPQExpBufferStr(ftStmt, dropStmt);
608  }
609  }
610 
611  ahprintf(AH, "%s", ftStmt->data);
612 
613  destroyPQExpBuffer(ftStmt);
614  pg_free(dropStmtOrig);
615  }
616  }
617  }
618  }
619  }
620 
621  /*
622  * _selectOutputSchema may have set currSchema to reflect the effect
623  * of a "SET search_path" command it emitted. However, by now we may
624  * have dropped that schema; or it might not have existed in the first
625  * place. In either case the effective value of search_path will not
626  * be what we think. Forcibly reset currSchema so that we will
627  * re-establish the search_path setting when needed (after creating
628  * the schema).
629  *
630  * If we treated users as pg_dump'able objects then we'd need to reset
631  * currUser here too.
632  */
633  free(AH->currSchema);
634  AH->currSchema = NULL;
635  }
636 
637  if (parallel_mode)
638  {
639  /*
640  * In parallel mode, turn control over to the parallel-restore logic.
641  */
642  ParallelState *pstate;
643  TocEntry pending_list;
644 
645  /* The archive format module may need some setup for this */
646  if (AH->PrepParallelRestorePtr)
647  AH->PrepParallelRestorePtr(AH);
648 
649  pending_list_header_init(&pending_list);
650 
651  /* This runs PRE_DATA items and then disconnects from the database */
652  restore_toc_entries_prefork(AH, &pending_list);
653  Assert(AH->connection == NULL);
654 
655  /* ParallelBackupStart() will actually fork the processes */
656  pstate = ParallelBackupStart(AH);
657  restore_toc_entries_parallel(AH, pstate, &pending_list);
658  ParallelBackupEnd(AH, pstate);
659 
660  /* reconnect the leader and see if we missed something */
661  restore_toc_entries_postfork(AH, &pending_list);
662  Assert(AH->connection != NULL);
663  }
664  else
665  {
666  /*
667  * In serial mode, process everything in three phases: normal items,
668  * then ACLs, then post-ACL items. We might be able to skip one or
669  * both extra phases in some cases, eg data-only restores.
670  */
671  bool haveACL = false;
672  bool havePostACL = false;
673 
674  for (te = AH->toc->next; te != AH->toc; te = te->next)
675  {
676  if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) == 0)
677  continue; /* ignore if not to be dumped at all */
678 
679  switch (_tocEntryRestorePass(te))
680  {
681  case RESTORE_PASS_MAIN:
682  (void) restore_toc_entry(AH, te, false);
683  break;
684  case RESTORE_PASS_ACL:
685  haveACL = true;
686  break;
687  case RESTORE_PASS_POST_ACL:
688  havePostACL = true;
689  break;
690  }
691  }
692 
693  if (haveACL)
694  {
695  for (te = AH->toc->next; te != AH->toc; te = te->next)
696  {
697  if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0 &&
698  _tocEntryRestorePass(te) == RESTORE_PASS_ACL)
699  (void) restore_toc_entry(AH, te, false);
700  }
701  }
702 
703  if (havePostACL)
704  {
705  for (te = AH->toc->next; te != AH->toc; te = te->next)
706  {
707  if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0 &&
708  _tocEntryRestorePass(te) == RESTORE_PASS_POST_ACL)
709  (void) restore_toc_entry(AH, te, false);
710  }
711  }
712  }
713 
714  if (ropt->single_txn)
715  {
716  if (AH->connection)
717  CommitTransaction(AHX);
718  else
719  ahprintf(AH, "COMMIT;\n\n");
720  }
721 
722  if (AH->public.verbose)
723  dumpTimestamp(AH, "Completed on", time(NULL));
724 
725  ahprintf(AH, "--\n-- PostgreSQL database dump complete\n--\n\n");
726 
727  /*
728  * Clean up & we're done.
729  */
730  AH->stage = STAGE_FINALIZING;
731 
732  if (ropt->filename || ropt->compression_spec.algorithm != PG_COMPRESSION_NONE)
733  RestoreOutput(AH, sav);
734 
735  if (ropt->useDB)
736  DisconnectDatabase(&AH->public);
737 }
738 
739 /*
740  * Restore a single TOC item. Used in both parallel and non-parallel restore;
741  * is_parallel is true if we are in a worker child process.
742  *
743  * Returns 0 normally, but WORKER_CREATE_DONE or WORKER_INHIBIT_DATA if
744  * the parallel parent has to make the corresponding status update.
745  */
746 static int
747 restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel)
748 {
749  RestoreOptions *ropt = AH->public.ropt;
750  int status = WORKER_OK;
751  int reqs;
752  bool defnDumped;
753 
754  AH->currentTE = te;
755 
756  /* Dump any relevant dump warnings to stderr */
757  if (!ropt->suppressDumpWarnings && strcmp(te->desc, "WARNING") == 0)
758  {
759  if (!ropt->dataOnly && te->defn != NULL && strlen(te->defn) != 0)
760  pg_log_warning("warning from original dump file: %s", te->defn);
761  else if (te->copyStmt != NULL && strlen(te->copyStmt) != 0)
762  pg_log_warning("warning from original dump file: %s", te->copyStmt);
763  }
764 
765  /* Work out what, if anything, we want from this entry */
766  reqs = te->reqs;
767 
768  defnDumped = false;
769 
770  /*
771  * If it has a schema component that we want, then process that
772  */
773  if ((reqs & REQ_SCHEMA) != 0)
774  {
775  /* Show namespace in log message if available */
776  if (te->namespace)
777  pg_log_info("creating %s \"%s.%s\"",
778  te->desc, te->namespace, te->tag);
779  else
780  pg_log_info("creating %s \"%s\"",
781  te->desc, te->tag);
782 
783  _printTocEntry(AH, te, false);
784  defnDumped = true;
785 
786  if (strcmp(te->desc, "TABLE") == 0)
787  {
788  if (AH->lastErrorTE == te)
789  {
790  /*
791  * We failed to create the table. If
792  * --no-data-for-failed-tables was given, mark the
793  * corresponding TABLE DATA to be ignored.
794  *
795  * In the parallel case this must be done in the parent, so we
796  * just set the return value.
797  */
798  if (ropt->noDataForFailedTables)
799  {
800  if (is_parallel)
801  status = WORKER_INHIBIT_DATA;
802  else
803  inhibit_data_for_failed_table(AH, te);
804  }
805  }
806  else
807  {
808  /*
809  * We created the table successfully. Mark the corresponding
810  * TABLE DATA for possible truncation.
811  *
812  * In the parallel case this must be done in the parent, so we
813  * just set the return value.
814  */
815  if (is_parallel)
816  status = WORKER_CREATE_DONE;
817  else
818  mark_create_done(AH, te);
819  }
820  }
821 
822  /*
823  * If we created a DB, connect to it. Also, if we changed DB
824  * properties, reconnect to ensure that relevant GUC settings are
825  * applied to our session.
826  */
827  if (strcmp(te->desc, "DATABASE") == 0 ||
828  strcmp(te->desc, "DATABASE PROPERTIES") == 0)
829  {
830  pg_log_info("connecting to new database \"%s\"", te->tag);
831  _reconnectToDB(AH, te->tag);
832  }
833  }
834 
835  /*
836  * If it has a data component that we want, then process that
837  */
838  if ((reqs & REQ_DATA) != 0)
839  {
840  /*
841  * hadDumper will be set if there is genuine data component for this
842  * node. Otherwise, we need to check the defn field for statements
843  * that need to be executed in data-only restores.
844  */
845  if (te->hadDumper)
846  {
847  /*
848  * If we can output the data, then restore it.
849  */
850  if (AH->PrintTocDataPtr != NULL)
851  {
852  _printTocEntry(AH, te, true);
853 
854  if (strcmp(te->desc, "BLOBS") == 0 ||
855  strcmp(te->desc, "BLOB COMMENTS") == 0)
856  {
857  pg_log_info("processing %s", te->desc);
858 
859  _selectOutputSchema(AH, "pg_catalog");
860 
861  /* Send BLOB COMMENTS data to ExecuteSimpleCommands() */
862  if (strcmp(te->desc, "BLOB COMMENTS") == 0)
863  AH->outputKind = OUTPUT_OTHERDATA;
864 
865  AH->PrintTocDataPtr(AH, te);
866 
867  AH->outputKind = OUTPUT_SQLCMDS;
868  }
869  else
870  {
871  bool use_truncate;
872 
873  _disableTriggersIfNecessary(AH, te);
874 
875  /* Select owner and schema as necessary */
876  _becomeOwner(AH, te);
877  _selectOutputSchema(AH, te->namespace);
878 
879  pg_log_info("processing data for table \"%s.%s\"",
880  te->namespace, te->tag);
881 
882  /*
883  * In parallel restore, if we created the table earlier in
884  * this run (so that we know it is empty) and we are not
885  * restoring a load-via-partition-root data item then we
886  * wrap the COPY in a transaction and precede it with a
887  * TRUNCATE. If wal_level is set to minimal this prevents
888  * WAL-logging the COPY. This obtains a speedup similar
889  * to that from using single_txn mode in non-parallel
890  * restores.
891  *
892  * We mustn't do this for load-via-partition-root cases
893  * because some data might get moved across partition
894  * boundaries, risking deadlock and/or loss of previously
895  * loaded data. (We assume that all partitions of a
896  * partitioned table will be treated the same way.)
897  */
898  use_truncate = is_parallel && te->created &&
899  !is_load_via_partition_root(te);
900 
901  if (use_truncate)
902  {
903  /*
904  * Parallel restore is always talking directly to a
905  * server, so no need to see if we should issue BEGIN.
906  */
907  StartTransaction(&AH->public);
908 
909  /*
910  * Issue TRUNCATE with ONLY so that child tables are
911  * not wiped.
912  */
913  ahprintf(AH, "TRUNCATE TABLE ONLY %s;\n\n",
914  fmtQualifiedId(te->namespace, te->tag));
915  }
916 
917  /*
918  * If we have a copy statement, use it.
919  */
920  if (te->copyStmt && strlen(te->copyStmt) > 0)
921  {
922  ahprintf(AH, "%s", te->copyStmt);
923  AH->outputKind = OUTPUT_COPYDATA;
924  }
925  else
926  AH->outputKind = OUTPUT_OTHERDATA;
927 
928  AH->PrintTocDataPtr(AH, te);
929 
930  /*
931  * Terminate COPY if needed.
932  */
933  if (AH->outputKind == OUTPUT_COPYDATA &&
934  RestoringToDB(AH))
935  EndDBCopyMode(&AH->public, te->tag);
936  AH->outputKind = OUTPUT_SQLCMDS;
937 
938  /* close out the transaction started above */
939  if (use_truncate)
940  CommitTransaction(&AH->public);
941 
942  _enableTriggersIfNecessary(AH, te);
943  }
944  }
945  }
946  else if (!defnDumped)
947  {
948  /* If we haven't already dumped the defn part, do so now */
949  pg_log_info("executing %s %s", te->desc, te->tag);
950  _printTocEntry(AH, te, false);
951  }
952  }
953 
954  if (AH->public.n_errors > 0 && status == WORKER_OK)
955  status = WORKER_IGNORED_ERRORS;
956 
957  return status;
958 }
959 
960 /*
961  * Allocate a new RestoreOptions block.
962  * This is mainly so we can initialize it, but also for future expansion,
963  */
964 RestoreOptions *
965 NewRestoreOptions(void)
966 {
967  RestoreOptions *opts;
968 
969  opts = (RestoreOptions *) pg_malloc0(sizeof(RestoreOptions));
970 
971  /* set any fields that shouldn't default to zeroes */
972  opts->format = archUnknown;
973  opts->cparams.promptPassword = TRI_DEFAULT;
974  opts->dumpSections = DUMP_UNSECTIONED;
975  opts->compression_spec.algorithm = PG_COMPRESSION_NONE;
976  opts->compression_spec.level = 0;
977 
978  return opts;
979 }
980 
981 static void
982 _disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te)
983 {
984  RestoreOptions *ropt = AH->public.ropt;
985 
986  /* This hack is only needed in a data-only restore */
987  if (!ropt->dataOnly || !ropt->disable_triggers)
988  return;
989 
990  pg_log_info("disabling triggers for %s", te->tag);
991 
992  /*
993  * Become superuser if possible, since they are the only ones who can
994  * disable constraint triggers. If -S was not given, assume the initial
995  * user identity is a superuser. (XXX would it be better to become the
996  * table owner?)
997  */
998  _becomeUser(AH, ropt->superuser);
999 
1000  /*
1001  * Disable them.
1002  */
1003  ahprintf(AH, "ALTER TABLE %s DISABLE TRIGGER ALL;\n\n",
1004  fmtQualifiedId(te->namespace, te->tag));
1005 }
1006 
1007 static void
1008 _enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te)
1009 {
1010  RestoreOptions *ropt = AH->public.ropt;
1011 
1012  /* This hack is only needed in a data-only restore */
1013  if (!ropt->dataOnly || !ropt->disable_triggers)
1014  return;
1015 
1016  pg_log_info("enabling triggers for %s", te->tag);
1017 
1018  /*
1019  * Become superuser if possible, since they are the only ones who can
1020  * disable constraint triggers. If -S was not given, assume the initial
1021  * user identity is a superuser. (XXX would it be better to become the
1022  * table owner?)
1023  */
1024  _becomeUser(AH, ropt->superuser);
1025 
1026  /*
1027  * Enable them.
1028  */
1029  ahprintf(AH, "ALTER TABLE %s ENABLE TRIGGER ALL;\n\n",
1030  fmtQualifiedId(te->namespace, te->tag));
1031 }
1032 
1033 /*
1034  * Detect whether a TABLE DATA TOC item is performing "load via partition
1035  * root", that is the target table is an ancestor partition rather than the
1036  * table the TOC item is nominally for.
1037  *
1038  * In newer archive files this can be detected by checking for a special
1039  * comment placed in te->defn. In older files we have to fall back to seeing
1040  * if the COPY statement targets the named table or some other one. This
1041  * will not work for data dumped as INSERT commands, so we could give a false
1042  * negative in that case; fortunately, that's a rarely-used option.
1043  */
1044 static bool
1045 is_load_via_partition_root(TocEntry *te)
1046 {
1047  if (te->defn &&
1048  strncmp(te->defn, "-- load via partition root ", 27) == 0)
1049  return true;
1050  if (te->copyStmt && *te->copyStmt)
1051  {
1052  PQExpBuffer copyStmt = createPQExpBuffer();
1053  bool result;
1054 
1055  /*
1056  * Build the initial part of the COPY as it would appear if the
1057  * nominal target table is the actual target. If we see anything
1058  * else, it must be a load-via-partition-root case.
1059  */
1060  appendPQExpBuffer(copyStmt, "COPY %s ",
1061  fmtQualifiedId(te->namespace, te->tag));
1062  result = strncmp(te->copyStmt, copyStmt->data, copyStmt->len) != 0;
1063  destroyPQExpBuffer(copyStmt);
1064  return result;
1065  }
1066  /* Assume it's not load-via-partition-root */
1067  return false;
1068 }
1069 
1070 /*
1071  * This is a routine that is part of the dumper interface, hence the 'Archive*' parameter.
1072  */
1073 
1074 /* Public */
1075 void
1076 WriteData(Archive *AHX, const void *data, size_t dLen)
1077 {
1078  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1079 
1080  if (!AH->currToc)
1081  pg_fatal("internal error -- WriteData cannot be called outside the context of a DataDumper routine");
1082 
1083  AH->WriteDataPtr(AH, data, dLen);
1084 }
1085 
1086 /*
1087  * Create a new TOC entry. The TOC was designed as a TOC, but is now the
1088  * repository for all metadata. But the name has stuck.
1089  *
1090  * The new entry is added to the Archive's TOC list. Most callers can ignore
1091  * the result value because nothing else need be done, but a few want to
1092  * manipulate the TOC entry further.
1093  */
1094 
1095 /* Public */
1096 TocEntry *
1097 ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId,
1098  ArchiveOpts *opts)
1099 {
1100  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1101  TocEntry *newToc;
1102 
1103  newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
1104 
1105  AH->tocCount++;
1106  if (dumpId > AH->maxDumpId)
1107  AH->maxDumpId = dumpId;
1108 
1109  newToc->prev = AH->toc->prev;
1110  newToc->next = AH->toc;
1111  AH->toc->prev->next = newToc;
1112  AH->toc->prev = newToc;
1113 
1114  newToc->catalogId = catalogId;
1115  newToc->dumpId = dumpId;
1116  newToc->section = opts->section;
1117 
1118  newToc->tag = pg_strdup(opts->tag);
1119  newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
1120  newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
1121  newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
1122  newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
1123  newToc->desc = pg_strdup(opts->description);
1124  newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
1125  newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
1126  newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
1127 
1128  if (opts->nDeps > 0)
1129  {
1130  newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
1131  memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
1132  newToc->nDeps = opts->nDeps;
1133  }
1134  else
1135  {
1136  newToc->dependencies = NULL;
1137  newToc->nDeps = 0;
1138  }
1139 
1140  newToc->dataDumper = opts->dumpFn;
1141  newToc->dataDumperArg = opts->dumpArg;
1142  newToc->hadDumper = opts->dumpFn ? true : false;
1143 
1144  newToc->formatData = NULL;
1145  newToc->dataLength = 0;
1146 
1147  if (AH->ArchiveEntryPtr != NULL)
1148  AH->ArchiveEntryPtr(AH, newToc);
1149 
1150  return newToc;
1151 }
1152 
1153 /* Public */
1154 void
1155 PrintTOCSummary(Archive *AHX)
1156 {
1157  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1158  RestoreOptions *ropt = AH->public.ropt;
1159  TocEntry *te;
1160  pg_compress_specification out_compression_spec = {0};
1161  teSection curSection;
1162  CompressFileHandle *sav;
1163  const char *fmtName;
1164  char stamp_str[64];
1165 
1166  /* TOC is always uncompressed */
1167  out_compression_spec.algorithm = PG_COMPRESSION_NONE;
1168 
1169  sav = SaveOutput(AH);
1170  if (ropt->filename)
1171  SetOutput(AH, ropt->filename, out_compression_spec);
1172 
1173  if (strftime(stamp_str, sizeof(stamp_str), PGDUMP_STRFTIME_FMT,
1174  localtime(&AH->createDate)) == 0)
1175  strcpy(stamp_str, "[unknown]");
1176 
1177  ahprintf(AH, ";\n; Archive created at %s\n", stamp_str);
1178  ahprintf(AH, "; dbname: %s\n; TOC Entries: %d\n; Compression: %s\n",
1179  sanitize_line(AH->archdbname, false),
1180  AH->tocCount,
1181  get_compress_algorithm_name(AH->compression_spec.algorithm));
1182 
1183  switch (AH->format)
1184  {
1185  case archCustom:
1186  fmtName = "CUSTOM";
1187  break;
1188  case archDirectory:
1189  fmtName = "DIRECTORY";
1190  break;
1191  case archTar:
1192  fmtName = "TAR";
1193  break;
1194  default:
1195  fmtName = "UNKNOWN";
1196  }
1197 
1198  ahprintf(AH, "; Dump Version: %d.%d-%d\n",
1199  ARCHIVE_MAJOR(AH->version), ARCHIVE_MINOR(AH->version), ARCHIVE_REV(AH->version));
1200  ahprintf(AH, "; Format: %s\n", fmtName);
1201  ahprintf(AH, "; Integer: %d bytes\n", (int) AH->intSize);
1202  ahprintf(AH, "; Offset: %d bytes\n", (int) AH->offSize);
1203  if (AH->archiveRemoteVersion)
1204  ahprintf(AH, "; Dumped from database version: %s\n",
1205  AH->archiveRemoteVersion);
1206  if (AH->archiveDumpVersion)
1207  ahprintf(AH, "; Dumped by pg_dump version: %s\n",
1208  AH->archiveDumpVersion);
1209 
1210  ahprintf(AH, ";\n;\n; Selected TOC Entries:\n;\n");
1211 
1212  curSection = SECTION_PRE_DATA;
1213  for (te = AH->toc->next; te != AH->toc; te = te->next)
1214  {
1215  if (te->section != SECTION_NONE)
1216  curSection = te->section;
1217  if (ropt->verbose ||
1218  (_tocEntryRequired(te, curSection, AH) & (REQ_SCHEMA | REQ_DATA)) != 0)
1219  {
1220  char *sanitized_name;
1221  char *sanitized_schema;
1222  char *sanitized_owner;
1223 
1224  /*
1225  */
1226  sanitized_name = sanitize_line(te->tag, false);
1227  sanitized_schema = sanitize_line(te->namespace, true);
1228  sanitized_owner = sanitize_line(te->owner, false);
1229 
1230  ahprintf(AH, "%d; %u %u %s %s %s %s\n", te->dumpId,
1231  te->catalogId.tableoid, te->catalogId.oid,
1232  te->desc, sanitized_schema, sanitized_name,
1233  sanitized_owner);
1234 
1235  free(sanitized_name);
1236  free(sanitized_schema);
1237  free(sanitized_owner);
1238  }
1239  if (ropt->verbose && te->nDeps > 0)
1240  {
1241  int i;
1242 
1243  ahprintf(AH, ";\tdepends on:");
1244  for (i = 0; i < te->nDeps; i++)
1245  ahprintf(AH, " %d", te->dependencies[i]);
1246  ahprintf(AH, "\n");
1247  }
1248  }
1249 
1250  /* Enforce strict names checking */
1251  if (ropt->strict_names)
1252  StrictNamesCheck(ropt);
1253 
1254  if (ropt->filename)
1255  RestoreOutput(AH, sav);
1256 }
1257 
1258 /***********
1259  * Large Object Archival
1260  ***********/
1261 
1262 /* Called by a dumper to signal start of a LO */
1263 int
1264 StartLO(Archive *AHX, Oid oid)
1265 {
1266  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1267 
1268  if (!AH->StartLOPtr)
1269  pg_fatal("large-object output not supported in chosen format");
1270 
1271  AH->StartLOPtr(AH, AH->currToc, oid);
1272 
1273  return 1;
1274 }
1275 
1276 /* Called by a dumper to signal end of a LO */
1277 int
1278 EndLO(Archive *AHX, Oid oid)
1279 {
1280  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1281 
1282  if (AH->EndLOPtr)
1283  AH->EndLOPtr(AH, AH->currToc, oid);
1284 
1285  return 1;
1286 }
1287 
1288 /**********
1289  * Large Object Restoration
1290  **********/
1291 
1292 /*
1293  * Called by a format handler before any LOs are restored
1294  */
1295 void
1296 StartRestoreLOs(ArchiveHandle *AH)
1297 {
1298  RestoreOptions *ropt = AH->public.ropt;
1299 
1300  if (!ropt->single_txn)
1301  {
1302  if (AH->connection)
1303  StartTransaction(&AH->public);
1304  else
1305  ahprintf(AH, "BEGIN;\n\n");
1306  }
1307 
1308  AH->loCount = 0;
1309 }
1310 
1311 /*
1312  * Called by a format handler after all LOs are restored
1313  */
1314 void
1315 EndRestoreLOs(ArchiveHandle *AH)
1316 {
1317  RestoreOptions *ropt = AH->public.ropt;
1318 
1319  if (!ropt->single_txn)
1320  {
1321  if (AH->connection)
1322  CommitTransaction(&AH->public);
1323  else
1324  ahprintf(AH, "COMMIT;\n\n");
1325  }
1326 
1327  pg_log_info(ngettext("restored %d large object",
1328  "restored %d large objects",
1329  AH->loCount),
1330  AH->loCount);
1331 }
1332 
1333 
1334 /*
1335  * Called by a format handler to initiate restoration of a LO
1336  */
1337 void
1338 StartRestoreLO(ArchiveHandle *AH, Oid oid, bool drop)
1339 {
1340  bool old_lo_style = (AH->version < K_VERS_1_12);
1341  Oid loOid;
1342 
1343  AH->loCount++;
1344 
1345  /* Initialize the LO Buffer */
1346  AH->lo_buf_used = 0;
1347 
1348  pg_log_info("restoring large object with OID %u", oid);
1349 
1350  /* With an old archive we must do drop and create logic here */
1351  if (old_lo_style && drop)
1352  DropLOIfExists(AH, oid);
1353 
1354  if (AH->connection)
1355  {
1356  if (old_lo_style)
1357  {
1358  loOid = lo_create(AH->connection, oid);
1359  if (loOid == 0 || loOid != oid)
1360  pg_fatal("could not create large object %u: %s",
1361  oid, PQerrorMessage(AH->connection));
1362  }
1363  AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
1364  if (AH->loFd == -1)
1365  pg_fatal("could not open large object %u: %s",
1366  oid, PQerrorMessage(AH->connection));
1367  }
1368  else
1369  {
1370  if (old_lo_style)
1371  ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
1372  oid, INV_WRITE);
1373  else
1374  ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
1375  oid, INV_WRITE);
1376  }
1377 
1378  AH->writingLO = true;
1379 }
1380 
1381 void
1382 EndRestoreLO(ArchiveHandle *AH, Oid oid)
1383 {
1384  if (AH->lo_buf_used > 0)
1385  {
1386  /* Write remaining bytes from the LO buffer */
1387  dump_lo_buf(AH);
1388  }
1389 
1390  AH->writingLO = false;
1391 
1392  if (AH->connection)
1393  {
1394  lo_close(AH->connection, AH->loFd);
1395  AH->loFd = -1;
1396  }
1397  else
1398  {
1399  ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
1400  }
1401 }
1402 
1403 /***********
1404  * Sorting and Reordering
1405  ***********/
1406 
1407 void
1408 SortTocFromFile(Archive *AHX)
1409 {
1410  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1411  RestoreOptions *ropt = AH->public.ropt;
1412  FILE *fh;
1413  StringInfoData linebuf;
1414 
1415  /* Allocate space for the 'wanted' array, and init it */
1416  ropt->idWanted = (bool *) pg_malloc0(sizeof(bool) * AH->maxDumpId);
1417 
1418  /* Setup the file */
1419  fh = fopen(ropt->tocFile, PG_BINARY_R);
1420  if (!fh)
1421  pg_fatal("could not open TOC file \"%s\": %m", ropt->tocFile);
1422 
1423  initStringInfo(&linebuf);
1424 
1425  while (pg_get_line_buf(fh, &linebuf))
1426  {
1427  char *cmnt;
1428  char *endptr;
1429  DumpId id;
1430  TocEntry *te;
1431 
1432  /* Truncate line at comment, if any */
1433  cmnt = strchr(linebuf.data, ';');
1434  if (cmnt != NULL)
1435  {
1436  cmnt[0] = '\0';
1437  linebuf.len = cmnt - linebuf.data;
1438  }
1439 
1440  /* Ignore if all blank */
1441  if (strspn(linebuf.data, " \t\r\n") == linebuf.len)
1442  continue;
1443 
1444  /* Get an ID, check it's valid and not already seen */
1445  id = strtol(linebuf.data, &endptr, 10);
1446  if (endptr == linebuf.data || id <= 0 || id > AH->maxDumpId ||
1447  ropt->idWanted[id - 1])
1448  {
1449  pg_log_warning("line ignored: %s", linebuf.data);
1450  continue;
1451  }
1452 
1453  /* Find TOC entry */
1454  te = getTocEntryByDumpId(AH, id);
1455  if (!te)
1456  pg_fatal("could not find entry for ID %d",
1457  id);
1458 
1459  /* Mark it wanted */
1460  ropt->idWanted[id - 1] = true;
1461 
1462  /*
1463  * Move each item to the end of the list as it is selected, so that
1464  * they are placed in the desired order. Any unwanted items will end
1465  * up at the front of the list, which may seem unintuitive but it's
1466  * what we need. In an ordinary serial restore that makes no
1467  * difference, but in a parallel restore we need to mark unrestored
1468  * items' dependencies as satisfied before we start examining
1469  * restorable items. Otherwise they could have surprising
1470  * side-effects on the order in which restorable items actually get
1471  * restored.
1472  */
1473  _moveBefore(AH->toc, te);
1474  }
1475 
1476  pg_free(linebuf.data);
1477 
1478  if (fclose(fh) != 0)
1479  pg_fatal("could not close TOC file: %m");
1480 }
1481 
1482 /**********************
1483  * Convenience functions that look like standard IO functions
1484  * for writing data when in dump mode.
1485  **********************/
1486 
1487 /* Public */
1488 void
1489 archputs(const char *s, Archive *AH)
1490 {
1491  WriteData(AH, s, strlen(s));
1492 }
1493 
1494 /* Public */
1495 int
1496 archprintf(Archive *AH, const char *fmt,...)
1497 {
1498  int save_errno = errno;
1499  char *p;
1500  size_t len = 128; /* initial assumption about buffer size */
1501  size_t cnt;
1502 
1503  for (;;)
1504  {
1505  va_list args;
1506 
1507  /* Allocate work buffer. */
1508  p = (char *) pg_malloc(len);
1509 
1510  /* Try to format the data. */
1511  errno = save_errno;
1512  va_start(args, fmt);
1513  cnt = pvsnprintf(p, len, fmt, args);
1514  va_end(args);
1515 
1516  if (cnt < len)
1517  break; /* success */
1518 
1519  /* Release buffer and loop around to try again with larger len. */
1520  free(p);
1521  len = cnt;
1522  }
1523 
1524  WriteData(AH, p, cnt);
1525  free(p);
1526  return (int) cnt;
1527 }
1528 
1529 
1530 /*******************************
1531  * Stuff below here should be 'private' to the archiver routines
1532  *******************************/
1533 
1534 static void
1535 SetOutput(ArchiveHandle *AH, const char *filename,
1536  const pg_compress_specification compression_spec)
1537 {
1538  CompressFileHandle *CFH;
1539  const char *mode;
1540  int fn = -1;
1541 
1542  if (filename)
1543  {
1544  if (strcmp(filename, "-") == 0)
1545  fn = fileno(stdout);
1546  }
1547  else if (AH->FH)
1548  fn = fileno(AH->FH);
1549  else if (AH->fSpec)
1550  {
1551  filename = AH->fSpec;
1552  }
1553  else
1554  fn = fileno(stdout);
1555 
1556  if (AH->mode == archModeAppend)
1557  mode = PG_BINARY_A;
1558  else
1559  mode = PG_BINARY_W;
1560 
1561  CFH = InitCompressFileHandle(compression_spec);
1562 
1563  if (!CFH->open_func(filename, fn, mode, CFH))
1564  {
1565  if (filename)
1566  pg_fatal("could not open output file \"%s\": %m", filename);
1567  else
1568  pg_fatal("could not open output file: %m");
1569  }
1570 
1571  AH->OF = CFH;
1572 }
1573 
1574 static CompressFileHandle *
1575 SaveOutput(ArchiveHandle *AH)
1576 {
1577  return (CompressFileHandle *) AH->OF;
1578 }
1579 
1580 static void
1581 RestoreOutput(ArchiveHandle *AH, CompressFileHandle *savedOutput)
1582 {
1583  errno = 0;
1584  if (!EndCompressFileHandle(AH->OF))
1585  pg_fatal("could not close output file: %m");
1586 
1587  AH->OF = savedOutput;
1588 }
1589 
1590 
1591 
1592 /*
1593  * Print formatted text to the output file (usually stdout).
1594  */
1595 int
1596 ahprintf(ArchiveHandle *AH, const char *fmt,...)
1597 {
1598  int save_errno = errno;
1599  char *p;
1600  size_t len = 128; /* initial assumption about buffer size */
1601  size_t cnt;
1602 
1603  for (;;)
1604  {
1605  va_list args;
1606 
1607  /* Allocate work buffer. */
1608  p = (char *) pg_malloc(len);
1609 
1610  /* Try to format the data. */
1611  errno = save_errno;
1612  va_start(args, fmt);
1613  cnt = pvsnprintf(p, len, fmt, args);
1614  va_end(args);
1615 
1616  if (cnt < len)
1617  break; /* success */
1618 
1619  /* Release buffer and loop around to try again with larger len. */
1620  free(p);
1621  len = cnt;
1622  }
1623 
1624  ahwrite(p, 1, cnt, AH);
1625  free(p);
1626  return (int) cnt;
1627 }
1628 
1629 /*
1630  * Single place for logic which says 'We are restoring to a direct DB connection'.
1631  */
1632 static int
1633 RestoringToDB(ArchiveHandle *AH)
1634 {
1635  RestoreOptions *ropt = AH->public.ropt;
1636 
1637  return (ropt && ropt->useDB && AH->connection);
1638 }
1639 
1640 /*
1641  * Dump the current contents of the LO data buffer while writing a LO
1642  */
1643 static void
1644 dump_lo_buf(ArchiveHandle *AH)
1645 {
1646  if (AH->connection)
1647  {
1648  int res;
1649 
1650  res = lo_write(AH->connection, AH->loFd, AH->lo_buf, AH->lo_buf_used);
1651  pg_log_debug(ngettext("wrote %zu byte of large object data (result = %d)",
1652  "wrote %zu bytes of large object data (result = %d)",
1653  AH->lo_buf_used),
1654  AH->lo_buf_used, res);
1655  /* We assume there are no short writes, only errors */
1656  if (res != AH->lo_buf_used)
1657  warn_or_exit_horribly(AH, "could not write to large object: %s",
1658  PQerrorMessage(AH->connection));
1659  }
1660  else
1661  {
1662  PQExpBuffer buf = createPQExpBuffer();
1663 
1664  appendByteaLiteralAHX(buf,
1665  (const unsigned char *) AH->lo_buf,
1666  AH->lo_buf_used,
1667  AH);
1668 
1669  /* Hack: turn off writingLO so ahwrite doesn't recurse to here */
1670  AH->writingLO = false;
1671  ahprintf(AH, "SELECT pg_catalog.lowrite(0, %s);\n", buf->data);
1672  AH->writingLO = true;
1673 
1674  destroyPQExpBuffer(buf);
1675  }
1676  AH->lo_buf_used = 0;
1677 }
1678 
1679 
1680 /*
1681  * Write buffer to the output file (usually stdout). This is used for
1682  * outputting 'restore' scripts etc. It is even possible for an archive
1683  * format to create a custom output routine to 'fake' a restore if it
1684  * wants to generate a script (see TAR output).
1685  */
1686 void
1687 ahwrite(const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)
1688 {
1689  int bytes_written = 0;
1690 
1691  if (AH->writingLO)
1692  {
1693  size_t remaining = size * nmemb;
1694 
1695  while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1696  {
1697  size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1698 
1699  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1700  ptr = (const void *) ((const char *) ptr + avail);
1701  remaining -= avail;
1702  AH->lo_buf_used += avail;
1703  dump_lo_buf(AH);
1704  }
1705 
1706  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1707  AH->lo_buf_used += remaining;
1708 
1709  bytes_written = size * nmemb;
1710  }
1711  else if (AH->CustomOutPtr)
1712  bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1713 
1714  /*
1715  * If we're doing a restore, and it's direct to DB, and we're connected
1716  * then send it to the DB.
1717  */
1718  else if (RestoringToDB(AH))
1719  bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1720  else
1721  {
1722  CompressFileHandle *CFH = (CompressFileHandle *) AH->OF;
1723 
1724  if (CFH->write_func(ptr, size * nmemb, CFH))
1725  bytes_written = size * nmemb;
1726  }
1727 
1728  if (bytes_written != size * nmemb)
1729  WRITE_ERROR_EXIT;
1730 }
1731 
1732 /* on some error, we may decide to go on... */
1733 void
1734 warn_or_exit_horribly(ArchiveHandle *AH, const char *fmt,...)
1735 {
1736  va_list ap;
1737 
1738  switch (AH->stage)
1739  {
1740 
1741  case STAGE_NONE:
1742  /* Do nothing special */
1743  break;
1744 
1745  case STAGE_INITIALIZING:
1746  if (AH->stage != AH->lastErrorStage)
1747  pg_log_info("while INITIALIZING:");
1748  break;
1749 
1750  case STAGE_PROCESSING:
1751  if (AH->stage != AH->lastErrorStage)
1752  pg_log_info("while PROCESSING TOC:");
1753  break;
1754 
1755  case STAGE_FINALIZING:
1756  if (AH->stage != AH->lastErrorStage)
1757  pg_log_info("while FINALIZING:");
1758  break;
1759  }
1760  if (AH->currentTE != NULL && AH->currentTE != AH->lastErrorTE)
1761  {
1762  pg_log_info("from TOC entry %d; %u %u %s %s %s",
1763  AH->currentTE->dumpId,
1764  AH->currentTE->catalogId.tableoid,
1765  AH->currentTE->catalogId.oid,
1766  AH->currentTE->desc ? AH->currentTE->desc : "(no desc)",
1767  AH->currentTE->tag ? AH->currentTE->tag : "(no tag)",
1768  AH->currentTE->owner ? AH->currentTE->owner : "(no owner)");
1769  }
1770  AH->lastErrorStage = AH->stage;
1771  AH->lastErrorTE = AH->currentTE;
1772 
1773  va_start(ap, fmt);
1774  pg_log_generic_v(PG_LOG_ERROR, PG_LOG_PRIMARY, fmt, ap);
1775  va_end(ap);
1776 
1777  if (AH->public.exit_on_error)
1778  exit_nicely(1);
1779  else
1780  AH->public.n_errors++;
1781 }
1782 
1783 #ifdef NOT_USED
1784 
1785 static void
1786 _moveAfter(ArchiveHandle *AH, TocEntry *pos, TocEntry *te)
1787 {
1788  /* Unlink te from list */
1789  te->prev->next = te->next;
1790  te->next->prev = te->prev;
1791 
1792  /* and insert it after "pos" */
1793  te->prev = pos;
1794  te->next = pos->next;
1795  pos->next->prev = te;
1796  pos->next = te;
1797 }
1798 #endif
1799 
1800 static void
1801 _moveBefore(TocEntry *pos, TocEntry *te)
1802 {
1803  /* Unlink te from list */
1804  te->prev->next = te->next;
1805  te->next->prev = te->prev;
1806 
1807  /* and insert it before "pos" */
1808  te->prev = pos->prev;
1809  te->next = pos;
1810  pos->prev->next = te;
1811  pos->prev = te;
1812 }
1813 
1814 /*
1815  * Build index arrays for the TOC list
1816  *
1817  * This should be invoked only after we have created or read in all the TOC
1818  * items.
1819  *
1820  * The arrays are indexed by dump ID (so entry zero is unused). Note that the
1821  * array entries run only up to maxDumpId. We might see dependency dump IDs
1822  * beyond that (if the dump was partial); so always check the array bound
1823  * before trying to touch an array entry.
1824  */
1825 static void
1826 buildTocEntryArrays(ArchiveHandle *AH)
1827 {
1828  DumpId maxDumpId = AH->maxDumpId;
1829  TocEntry *te;
1830 
1831  AH->tocsByDumpId = (TocEntry **) pg_malloc0((maxDumpId + 1) * sizeof(TocEntry *));
1832  AH->tableDataId = (DumpId *) pg_malloc0((maxDumpId + 1) * sizeof(DumpId));
1833 
1834  for (te = AH->toc->next; te != AH->toc; te = te->next)
1835  {
1836  /* this check is purely paranoia, maxDumpId should be correct */
1837  if (te->dumpId <= 0 || te->dumpId > maxDumpId)
1838  pg_fatal("bad dumpId");
1839 
1840  /* tocsByDumpId indexes all TOCs by their dump ID */
1841  AH->tocsByDumpId[te->dumpId] = te;
1842 
1843  /*
1844  * tableDataId provides the TABLE DATA item's dump ID for each TABLE
1845  * TOC entry that has a DATA item. We compute this by reversing the
1846  * TABLE DATA item's dependency, knowing that a TABLE DATA item has
1847  * just one dependency and it is the TABLE item.
1848  */
1849  if (strcmp(te->desc, "TABLE DATA") == 0 && te->nDeps > 0)
1850  {
1851  DumpId tableId = te->dependencies[0];
1852 
1853  /*
1854  * The TABLE item might not have been in the archive, if this was
1855  * a data-only dump; but its dump ID should be less than its data
1856  * item's dump ID, so there should be a place for it in the array.
1857  */
1858  if (tableId <= 0 || tableId > maxDumpId)
1859  pg_fatal("bad table dumpId for TABLE DATA item");
1860 
1861  AH->tableDataId[tableId] = te->dumpId;
1862  }
1863  }
1864 }
1865 
1866 TocEntry *
1867 getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)
1868 {
1869  /* build index arrays if we didn't already */
1870  if (AH->tocsByDumpId == NULL)
1871  buildTocEntryArrays(AH);
1872 
1873  if (id > 0 && id <= AH->maxDumpId)
1874  return AH->tocsByDumpId[id];
1875 
1876  return NULL;
1877 }
1878 
1879 int
1880 TocIDRequired(ArchiveHandle *AH, DumpId id)
1881 {
1882  TocEntry *te = getTocEntryByDumpId(AH, id);
1883 
1884  if (!te)
1885  return 0;
1886 
1887  return te->reqs;
1888 }
1889 
1890 size_t
1891 WriteOffset(ArchiveHandle *AH, pgoff_t o, int wasSet)
1892 {
1893  int off;
1894 
1895  /* Save the flag */
1896  AH->WriteBytePtr(AH, wasSet);
1897 
1898  /* Write out pgoff_t smallest byte first, prevents endian mismatch */
1899  for (off = 0; off < sizeof(pgoff_t); off++)
1900  {
1901  AH->WriteBytePtr(AH, o & 0xFF);
1902  o >>= 8;
1903  }
1904  return sizeof(pgoff_t) + 1;
1905 }
1906 
1907 int
1908 ReadOffset(ArchiveHandle *AH, pgoff_t * o)
1909 {
1910  int i;
1911  int off;
1912  int offsetFlg;
1913 
1914  /* Initialize to zero */
1915  *o = 0;
1916 
1917  /* Check for old version */
1918  if (AH->version < K_VERS_1_7)
1919  {
1920  /* Prior versions wrote offsets using WriteInt */
1921  i = ReadInt(AH);
1922  /* -1 means not set */
1923  if (i < 0)
1924  return K_OFFSET_POS_NOT_SET;
1925  else if (i == 0)
1926  return K_OFFSET_NO_DATA;
1927 
1928  /* Cast to pgoff_t because it was written as an int. */
1929  *o = (pgoff_t) i;
1930  return K_OFFSET_POS_SET;
1931  }
1932 
1933  /*
1934  * Read the flag indicating the state of the data pointer. Check if valid
1935  * and die if not.
1936  *
1937  * This used to be handled by a negative or zero pointer, now we use an
1938  * extra byte specifically for the state.
1939  */
1940  offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
1941 
1942  switch (offsetFlg)
1943  {
1944  case K_OFFSET_POS_NOT_SET:
1945  case K_OFFSET_NO_DATA:
1946  case K_OFFSET_POS_SET:
1947 
1948  break;
1949 
1950  default:
1951  pg_fatal("unexpected data offset flag %d", offsetFlg);
1952  }
1953 
1954  /*
1955  * Read the bytes
1956  */
1957  for (off = 0; off < AH->offSize; off++)
1958  {
1959  if (off < sizeof(pgoff_t))
1960  *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
1961  else
1962  {
1963  if (AH->ReadBytePtr(AH) != 0)
1964  pg_fatal("file offset in dump file is too large");
1965  }
1966  }
1967 
1968  return offsetFlg;
1969 }
1970 
1971 size_t
1972 WriteInt(ArchiveHandle *AH, int i)
1973 {
1974  int b;
1975 
1976  /*
1977  * This is a bit yucky, but I don't want to make the binary format very
1978  * dependent on representation, and not knowing much about it, I write out
1979  * a sign byte. If you change this, don't forget to change the file
1980  * version #, and modify ReadInt to read the new format AS WELL AS the old
1981  * formats.
1982  */
1983 
1984  /* SIGN byte */
1985  if (i < 0)
1986  {
1987  AH->WriteBytePtr(AH, 1);
1988  i = -i;
1989  }
1990  else
1991  AH->WriteBytePtr(AH, 0);
1992 
1993  for (b = 0; b < AH->intSize; b++)
1994  {
1995  AH->WriteBytePtr(AH, i & 0xFF);
1996  i >>= 8;
1997  }
1998 
1999  return AH->intSize + 1;
2000 }
2001 
2002 int
2003 ReadInt(ArchiveHandle *AH)
2004 {
2005  int res = 0;
2006  int bv,
2007  b;
2008  int sign = 0; /* Default positive */
2009  int bitShift = 0;
2010 
2011  if (AH->version > K_VERS_1_0)
2012  /* Read a sign byte */
2013  sign = AH->ReadBytePtr(AH);
2014 
2015  for (b = 0; b < AH->intSize; b++)
2016  {
2017  bv = AH->ReadBytePtr(AH) & 0xFF;
2018  if (bv != 0)
2019  res = res + (bv << bitShift);
2020  bitShift += 8;
2021  }
2022 
2023  if (sign)
2024  res = -res;
2025 
2026  return res;
2027 }
2028 
2029 size_t
2030 WriteStr(ArchiveHandle *AH, const char *c)
2031 {
2032  size_t res;
2033 
2034  if (c)
2035  {
2036  int len = strlen(c);
2037 
2038  res = WriteInt(AH, len);
2039  AH->WriteBufPtr(AH, c, len);
2040  res += len;
2041  }
2042  else
2043  res = WriteInt(AH, -1);
2044 
2045  return res;
2046 }
2047 
2048 char *
2049 ReadStr(ArchiveHandle *AH)
2050 {
2051  char *buf;
2052  int l;
2053 
2054  l = ReadInt(AH);
2055  if (l < 0)
2056  buf = NULL;
2057  else
2058  {
2059  buf = (char *) pg_malloc(l + 1);
2060  AH->ReadBufPtr(AH, (void *) buf, l);
2061 
2062  buf[l] = '\0';
2063  }
2064 
2065  return buf;
2066 }
2067 
2068 static bool
2069 _fileExistsInDirectory(const char *dir, const char *filename)
2070 {
2071  struct stat st;
2072  char buf[MAXPGPATH];
2073 
2074  if (snprintf(buf, MAXPGPATH, "%s/%s", dir, filename) >= MAXPGPATH)
2075  pg_fatal("directory name too long: \"%s\"", dir);
2076 
2077  return (stat(buf, &st) == 0 && S_ISREG(st.st_mode));
2078 }
2079 
2080 static int
2081 _discoverArchiveFormat(ArchiveHandle *AH)
2082 {
2083  FILE *fh;
2084  char sig[6]; /* More than enough */
2085  size_t cnt;
2086  int wantClose = 0;
2087 
2088  pg_log_debug("attempting to ascertain archive format");
2089 
2090  free(AH->lookahead);
2091 
2092  AH->readHeader = 0;
2093  AH->lookaheadSize = 512;
2094  AH->lookahead = pg_malloc0(512);
2095  AH->lookaheadLen = 0;
2096  AH->lookaheadPos = 0;
2097 
2098  if (AH->fSpec)
2099  {
2100  struct stat st;
2101 
2102  wantClose = 1;
2103 
2104  /*
2105  * Check if the specified archive is a directory. If so, check if
2106  * there's a "toc.dat" (or "toc.dat.{gz,lz4,zst}") file in it.
2107  */
2108  if (stat(AH->fSpec, &st) == 0 && S_ISDIR(st.st_mode))
2109  {
2110  AH->format = archDirectory;
2111  if (_fileExistsInDirectory(AH->fSpec, "toc.dat"))
2112  return AH->format;
2113 #ifdef HAVE_LIBZ
2114  if (_fileExistsInDirectory(AH->fSpec, "toc.dat.gz"))
2115  return AH->format;
2116 #endif
2117 #ifdef USE_LZ4
2118  if (_fileExistsInDirectory(AH->fSpec, "toc.dat.lz4"))
2119  return AH->format;
2120 #endif
2121 #ifdef USE_ZSTD
2122  if (_fileExistsInDirectory(AH->fSpec, "toc.dat.zst"))
2123  return AH->format;
2124 #endif
2125  pg_fatal("directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not exist)",
2126  AH->fSpec);
2127  fh = NULL; /* keep compiler quiet */
2128  }
2129  else
2130  {
2131  fh = fopen(AH->fSpec, PG_BINARY_R);
2132  if (!fh)
2133  pg_fatal("could not open input file \"%s\": %m", AH->fSpec);
2134  }
2135  }
2136  else
2137  {
2138  fh = stdin;
2139  if (!fh)
2140  pg_fatal("could not open input file: %m");
2141  }
2142 
2143  if ((cnt = fread(sig, 1, 5, fh)) != 5)
2144  {
2145  if (ferror(fh))
2146  pg_fatal("could not read input file: %m");
2147  else
2148  pg_fatal("input file is too short (read %lu, expected 5)",
2149  (unsigned long) cnt);
2150  }
2151 
2152  /* Save it, just in case we need it later */
2153  memcpy(&AH->lookahead[0], sig, 5);
2154  AH->lookaheadLen = 5;
2155 
2156  if (strncmp(sig, "PGDMP", 5) == 0)
2157  {
2158  /* It's custom format, stop here */
2159  AH->format = archCustom;
2160  AH->readHeader = 1;
2161  }
2162  else
2163  {
2164  /*
2165  * *Maybe* we have a tar archive format file or a text dump ... So,
2166  * read first 512 byte header...
2167  */
2168  cnt = fread(&AH->lookahead[AH->lookaheadLen], 1, 512 - AH->lookaheadLen, fh);
2169  /* read failure is checked below */
2170  AH->lookaheadLen += cnt;
2171 
2172  if (AH->lookaheadLen >= strlen(TEXT_DUMPALL_HEADER) &&
2173  (strncmp(AH->lookahead, TEXT_DUMP_HEADER, strlen(TEXT_DUMP_HEADER)) == 0 ||
2174  strncmp(AH->lookahead, TEXT_DUMPALL_HEADER, strlen(TEXT_DUMPALL_HEADER)) == 0))
2175  {
2176  /*
2177  * looks like it's probably a text format dump. so suggest they
2178  * try psql
2179  */
2180  pg_fatal("input file appears to be a text format dump. Please use psql.");
2181  }
2182 
2183  if (AH->lookaheadLen != 512)
2184  {
2185  if (feof(fh))
2186  pg_fatal("input file does not appear to be a valid archive (too short?)");
2187  else
2188  READ_ERROR_EXIT(fh);
2189  }
2190 
2191  if (!isValidTarHeader(AH->lookahead))
2192  pg_fatal("input file does not appear to be a valid archive");
2193 
2194  AH->format = archTar;
2195  }
2196 
2197  /* Close the file if we opened it */
2198  if (wantClose)
2199  {
2200  if (fclose(fh) != 0)
2201  pg_fatal("could not close input file: %m");
2202  /* Forget lookahead, since we'll re-read header after re-opening */
2203  AH->readHeader = 0;
2204  AH->lookaheadLen = 0;
2205  }
2206 
2207  return AH->format;
2208 }
2209 
2210 
2211 /*
2212  * Allocate an archive handle
2213  */
2214 static ArchiveHandle *
2215 _allocAH(const char *FileSpec, const ArchiveFormat fmt,
2216  const pg_compress_specification compression_spec,
2217  bool dosync, ArchiveMode mode,
2218  SetupWorkerPtrType setupWorkerPtr, DataDirSyncMethod sync_method)
2219 {
2220  ArchiveHandle *AH;
2221  CompressFileHandle *CFH;
2222  pg_compress_specification out_compress_spec = {0};
2223 
2224  pg_log_debug("allocating AH for %s, format %d",
2225  FileSpec ? FileSpec : "(stdio)", fmt);
2226 
2227  AH = (ArchiveHandle *) pg_malloc0(sizeof(ArchiveHandle));
2228 
2229  AH->version = K_VERS_SELF;
2230 
2231  /* initialize for backwards compatible string processing */
2232  AH->public.encoding = 0; /* PG_SQL_ASCII */
2233  AH->public.std_strings = false;
2234 
2235  /* sql error handling */
2236  AH->public.exit_on_error = true;
2237  AH->public.n_errors = 0;
2238 
2239  AH->archiveDumpVersion = PG_VERSION;
2240 
2241  AH->createDate = time(NULL);
2242 
2243  AH->intSize = sizeof(int);
2244  AH->offSize = sizeof(pgoff_t);
2245  if (FileSpec)
2246  {
2247  AH->fSpec = pg_strdup(FileSpec);
2248 
2249  /*
2250  * Not used; maybe later....
2251  *
2252  * AH->workDir = pg_strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
2253  * i--) if (AH->workDir[i-1] == '/')
2254  */
2255  }
2256  else
2257  AH->fSpec = NULL;
2258 
2259  AH->currUser = NULL; /* unknown */
2260  AH->currSchema = NULL; /* ditto */
2261  AH->currTablespace = NULL; /* ditto */
2262  AH->currTableAm = NULL; /* ditto */
2263 
2264  AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
2265 
2266  AH->toc->next = AH->toc;
2267  AH->toc->prev = AH->toc;
2268 
2269  AH->mode = mode;
2270  AH->compression_spec = compression_spec;
2271  AH->dosync = dosync;
2272  AH->sync_method = sync_method;
2273 
2274  memset(&(AH->sqlparse), 0, sizeof(AH->sqlparse));
2275 
2276  /* Open stdout with no compression for AH output handle */
2277  out_compress_spec.algorithm = PG_COMPRESSION_NONE;
2278  CFH = InitCompressFileHandle(out_compress_spec);
2279  if (!CFH->open_func(NULL, fileno(stdout), PG_BINARY_A, CFH))
2280  pg_fatal("could not open stdout for appending: %m");
2281  AH->OF = CFH;
2282 
2283  /*
2284  * On Windows, we need to use binary mode to read/write non-text files,
2285  * which include all archive formats as well as compressed plain text.
2286  * Force stdin/stdout into binary mode if that is what we are using.
2287  */
2288 #ifdef WIN32
2289  if ((fmt != archNull || compression_spec.algorithm != PG_COMPRESSION_NONE) &&
2290  (AH->fSpec == NULL || strcmp(AH->fSpec, "") == 0))
2291  {
2292  if (mode == archModeWrite)
2293  _setmode(fileno(stdout), O_BINARY);
2294  else
2295  _setmode(fileno(stdin), O_BINARY);
2296  }
2297 #endif
2298 
2299  AH->SetupWorkerPtr = setupWorkerPtr;
2300 
2301  if (fmt == archUnknown)
2302  AH->format = _discoverArchiveFormat(AH);
2303  else
2304  AH->format = fmt;
2305 
2306  switch (AH->format)
2307  {
2308  case archCustom:
2309  InitArchiveFmt_Custom(AH);
2310  break;
2311 
2312  case archNull:
2313  InitArchiveFmt_Null(AH);
2314  break;
2315 
2316  case archDirectory:
2317  InitArchiveFmt_Directory(AH);
2318  break;
2319 
2320  case archTar:
2321  InitArchiveFmt_Tar(AH);
2322  break;
2323 
2324  default:
2325  pg_fatal("unrecognized file format \"%d\"", fmt);
2326  }
2327 
2328  return AH;
2329 }
2330 
2331 /*
2332  * Write out all data (tables & LOs)
2333  */
2334 void
2335 WriteDataChunks(ArchiveHandle *AH, ParallelState *pstate)
2336 {
2337  TocEntry *te;
2338 
2339  if (pstate && pstate->numWorkers > 1)
2340  {
2341  /*
2342  * In parallel mode, this code runs in the leader process. We
2343  * construct an array of candidate TEs, then sort it into decreasing
2344  * size order, then dispatch each TE to a data-transfer worker. By
2345  * dumping larger tables first, we avoid getting into a situation
2346  * where we're down to one job and it's big, losing parallelism.
2347  */
2348  TocEntry **tes;
2349  int ntes;
2350 
2351  tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
2352  ntes = 0;
2353  for (te = AH->toc->next; te != AH->toc; te = te->next)
2354  {
2355  /* Consider only TEs with dataDumper functions ... */
2356  if (!te->dataDumper)
2357  continue;
2358  /* ... and ignore ones not enabled for dump */
2359  if ((te->reqs & REQ_DATA) == 0)
2360  continue;
2361 
2362  tes[ntes++] = te;
2363  }
2364 
2365  if (ntes > 1)
2366  qsort(tes, ntes, sizeof(TocEntry *), TocEntrySizeCompareQsort);
2367 
2368  for (int i = 0; i < ntes; i++)
2369  DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
2370  mark_dump_job_done, NULL);
2371 
2372  pg_free(tes);
2373 
2374  /* Now wait for workers to finish. */
2375  WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2376  }
2377  else
2378  {
2379  /* Non-parallel mode: just dump all candidate TEs sequentially. */
2380  for (te = AH->toc->next; te != AH->toc; te = te->next)
2381  {
2382  /* Must have same filter conditions as above */
2383  if (!te->dataDumper)
2384  continue;
2385  if ((te->reqs & REQ_DATA) == 0)
2386  continue;
2387 
2388  WriteDataChunksForTocEntry(AH, te);
2389  }
2390  }
2391 }
2392 
2393 
2394 /*
2395  * Callback function that's invoked in the leader process after a step has
2396  * been parallel dumped.
2397  *
2398  * We don't need to do anything except check for worker failure.
2399  */
2400 static void
2401 mark_dump_job_done(ArchiveHandle *AH,
2402  TocEntry *te,
2403  int status,
2404  void *callback_data)
2405 {
2406  pg_log_info("finished item %d %s %s",
2407  te->dumpId, te->desc, te->tag);
2408 
2409  if (status != 0)
2410  pg_fatal("worker process failed: exit code %d",
2411  status);
2412 }
2413 
2414 
2415 void
2416 WriteDataChunksForTocEntry(ArchiveHandle *AH, TocEntry *te)
2417 {
2418  StartDataPtrType startPtr;
2419  EndDataPtrType endPtr;
2420 
2421  AH->currToc = te;
2422 
2423  if (strcmp(te->desc, "BLOBS") == 0)
2424  {
2425  startPtr = AH->StartLOsPtr;
2426  endPtr = AH->EndLOsPtr;
2427  }
2428  else
2429  {
2430  startPtr = AH->StartDataPtr;
2431  endPtr = AH->EndDataPtr;
2432  }
2433 
2434  if (startPtr != NULL)
2435  (*startPtr) (AH, te);
2436 
2437  /*
2438  * The user-provided DataDumper routine needs to call AH->WriteData
2439  */
2440  te->dataDumper((Archive *) AH, te->dataDumperArg);
2441 
2442  if (endPtr != NULL)
2443  (*endPtr) (AH, te);
2444 
2445  AH->currToc = NULL;
2446 }
2447 
2448 void
2449 WriteToc(ArchiveHandle *AH)
2450 {
2451  TocEntry *te;
2452  char workbuf[32];
2453  int tocCount;
2454  int i;
2455 
2456  /* count entries that will actually be dumped */
2457  tocCount = 0;
2458  for (te = AH->toc->next; te != AH->toc; te = te->next)
2459  {
2460  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
2461  tocCount++;
2462  }
2463 
2464  /* printf("%d TOC Entries to save\n", tocCount); */
2465 
2466  WriteInt(AH, tocCount);
2467 
2468  for (te = AH->toc->next; te != AH->toc; te = te->next)
2469  {
2470  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) == 0)
2471  continue;
2472 
2473  WriteInt(AH, te->dumpId);
2474  WriteInt(AH, te->dataDumper ? 1 : 0);
2475 
2476  /* OID is recorded as a string for historical reasons */
2477  sprintf(workbuf, "%u", te->catalogId.tableoid);
2478  WriteStr(AH, workbuf);
2479  sprintf(workbuf, "%u", te->catalogId.oid);
2480  WriteStr(AH, workbuf);
2481 
2482  WriteStr(AH, te->tag);
2483  WriteStr(AH, te->desc);
2484  WriteInt(AH, te->section);
2485  WriteStr(AH, te->defn);
2486  WriteStr(AH, te->dropStmt);
2487  WriteStr(AH, te->copyStmt);
2488  WriteStr(AH, te->namespace);
2489  WriteStr(AH, te->tablespace);
2490  WriteStr(AH, te->tableam);
2491  WriteStr(AH, te->owner);
2492  WriteStr(AH, "false");
2493 
2494  /* Dump list of dependencies */
2495  for (i = 0; i < te->nDeps; i++)
2496  {
2497  sprintf(workbuf, "%d", te->dependencies[i]);
2498  WriteStr(AH, workbuf);
2499  }
2500  WriteStr(AH, NULL); /* Terminate List */
2501 
2502  if (AH->WriteExtraTocPtr)
2503  AH->WriteExtraTocPtr(AH, te);
2504  }
2505 }
2506 
2507 void
2508 ReadToc(ArchiveHandle *AH)
2509 {
2510  int i;
2511  char *tmp;
2512  DumpId *deps;
2513  int depIdx;
2514  int depSize;
2515  TocEntry *te;
2516  bool is_supported;
2517 
2518  AH->tocCount = ReadInt(AH);
2519  AH->maxDumpId = 0;
2520 
2521  for (i = 0; i < AH->tocCount; i++)
2522  {
2523  te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
2524  te->dumpId = ReadInt(AH);
2525 
2526  if (te->dumpId > AH->maxDumpId)
2527  AH->maxDumpId = te->dumpId;
2528 
2529  /* Sanity check */
2530  if (te->dumpId <= 0)
2531  pg_fatal("entry ID %d out of range -- perhaps a corrupt TOC",
2532  te->dumpId);
2533 
2534  te->hadDumper = ReadInt(AH);
2535 
2536  if (AH->version >= K_VERS_1_8)
2537  {
2538  tmp = ReadStr(AH);
2539  sscanf(tmp, "%u", &te->catalogId.tableoid);
2540  free(tmp);
2541  }
2542  else
2543  te->catalogId.tableoid = InvalidOid;
2544  tmp = ReadStr(AH);
2545  sscanf(tmp, "%u", &te->catalogId.oid);
2546  free(tmp);
2547 
2548  te->tag = ReadStr(AH);
2549  te->desc = ReadStr(AH);
2550 
2551  if (AH->version >= K_VERS_1_11)
2552  {
2553  te->section = ReadInt(AH);
2554  }
2555  else
2556  {
2557  /*
2558  * Rules for pre-8.4 archives wherein pg_dump hasn't classified
2559  * the entries into sections. This list need not cover entry
2560  * types added later than 8.4.
2561  */
2562  if (strcmp(te->desc, "COMMENT") == 0 ||
2563  strcmp(te->desc, "ACL") == 0 ||
2564  strcmp(te->desc, "ACL LANGUAGE") == 0)
2565  te->section = SECTION_NONE;
2566  else if (strcmp(te->desc, "TABLE DATA") == 0 ||
2567  strcmp(te->desc, "BLOBS") == 0 ||
2568  strcmp(te->desc, "BLOB COMMENTS") == 0)
2569  te->section = SECTION_DATA;
2570  else if (strcmp(te->desc, "CONSTRAINT") == 0 ||
2571  strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
2572  strcmp(te->desc, "FK CONSTRAINT") == 0 ||
2573  strcmp(te->desc, "INDEX") == 0 ||
2574  strcmp(te->desc, "RULE") == 0 ||
2575  strcmp(te->desc, "TRIGGER") == 0)
2576  te->section = SECTION_POST_DATA;
2577  else
2578  te->section = SECTION_PRE_DATA;
2579  }
2580 
2581  te->defn = ReadStr(AH);
2582  te->dropStmt = ReadStr(AH);
2583 
2584  if (AH->version >= K_VERS_1_3)
2585  te->copyStmt = ReadStr(AH);
2586 
2587  if (AH->version >= K_VERS_1_6)
2588  te->namespace = ReadStr(AH);
2589 
2590  if (AH->version >= K_VERS_1_10)
2591  te->tablespace = ReadStr(AH);
2592 
2593  if (AH->version >= K_VERS_1_14)
2594  te->tableam = ReadStr(AH);
2595 
2596  te->owner = ReadStr(AH);
2597  is_supported = true;
2598  if (AH->version < K_VERS_1_9)
2599  is_supported = false;
2600  else
2601  {
2602  tmp = ReadStr(AH);
2603 
2604  if (strcmp(tmp, "true") == 0)
2605  is_supported = false;
2606 
2607  free(tmp);
2608  }
2609 
2610  if (!is_supported)
2611  pg_log_warning("restoring tables WITH OIDS is not supported anymore");
2612 
2613  /* Read TOC entry dependencies */
2614  if (AH->version >= K_VERS_1_5)
2615  {
2616  depSize = 100;
2617  deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
2618  depIdx = 0;
2619  for (;;)
2620  {
2621  tmp = ReadStr(AH);
2622  if (!tmp)
2623  break; /* end of list */
2624  if (depIdx >= depSize)
2625  {
2626  depSize *= 2;
2627  deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depSize);
2628  }
2629  sscanf(tmp, "%d", &deps[depIdx]);
2630  free(tmp);
2631  depIdx++;
2632  }
2633 
2634  if (depIdx > 0) /* We have a non-null entry */
2635  {
2636  deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depIdx);
2637  te->dependencies = deps;
2638  te->nDeps = depIdx;
2639  }
2640  else
2641  {
2642  free(deps);
2643  te->dependencies = NULL;
2644  te->nDeps = 0;
2645  }
2646  }
2647  else
2648  {
2649  te->dependencies = NULL;
2650  te->nDeps = 0;
2651  }
2652  te->dataLength = 0;
2653 
2654  if (AH->ReadExtraTocPtr)
2655  AH->ReadExtraTocPtr(AH, te);
2656 
2657  pg_log_debug("read TOC entry %d (ID %d) for %s %s",
2658  i, te->dumpId, te->desc, te->tag);
2659 
2660  /* link completed entry into TOC circular list */
2661  te->prev = AH->toc->prev;
2662  AH->toc->prev->next = te;
2663  AH->toc->prev = te;
2664  te->next = AH->toc;
2665 
2666  /* special processing immediately upon read for some items */
2667  if (strcmp(te->desc, "ENCODING") == 0)
2668  processEncodingEntry(AH, te);
2669  else if (strcmp(te->desc, "STDSTRINGS") == 0)
2670  processStdStringsEntry(AH, te);
2671  else if (strcmp(te->desc, "SEARCHPATH") == 0)
2672  processSearchPathEntry(AH, te);
2673  }
2674 }
2675 
2676 static void
2677 processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
2678 {
2679  /* te->defn should have the form SET client_encoding = 'foo'; */
2680  char *defn = pg_strdup(te->defn);
2681  char *ptr1;
2682  char *ptr2 = NULL;
2683  int encoding;
2684 
2685  ptr1 = strchr(defn, '\'');
2686  if (ptr1)
2687  ptr2 = strchr(++ptr1, '\'');
2688  if (ptr2)
2689  {
2690  *ptr2 = '\0';
2691  encoding = pg_char_to_encoding(ptr1);
2692  if (encoding < 0)
2693  pg_fatal("unrecognized encoding \"%s\"",
2694  ptr1);
2695  AH->public.encoding = encoding;
2696  }
2697  else
2698  pg_fatal("invalid ENCODING item: %s",
2699  te->defn);
2700 
2701  free(defn);
2702 }
2703 
2704 static void
2705 processStdStringsEntry(ArchiveHandle *AH, TocEntry *te)
2706 {
2707  /* te->defn should have the form SET standard_conforming_strings = 'x'; */
2708  char *ptr1;
2709 
2710  ptr1 = strchr(te->defn, '\'');
2711  if (ptr1 && strncmp(ptr1, "'on'", 4) == 0)
2712  AH->public.std_strings = true;
2713  else if (ptr1 && strncmp(ptr1, "'off'", 5) == 0)
2714  AH->public.std_strings = false;
2715  else
2716  pg_fatal("invalid STDSTRINGS item: %s",
2717  te->defn);
2718 }
2719 
2720 static void
2721 processSearchPathEntry(ArchiveHandle *AH, TocEntry *te)
2722 {
2723  /*
2724  * te->defn should contain a command to set search_path. We just copy it
2725  * verbatim for use later.
2726  */
2727  AH->public.searchpath = pg_strdup(te->defn);
2728 }
2729 
2730 static void
2731 StrictNamesCheck(RestoreOptions *ropt)
2732 {
2733  const char *missing_name;
2734 
2735  Assert(ropt->strict_names);
2736 
2737  if (ropt->schemaNames.head != NULL)
2738  {
2739  missing_name = simple_string_list_not_touched(&ropt->schemaNames);
2740  if (missing_name != NULL)
2741  pg_fatal("schema \"%s\" not found", missing_name);
2742  }
2743 
2744  if (ropt->tableNames.head != NULL)
2745  {
2746  missing_name = simple_string_list_not_touched(&ropt->tableNames);
2747  if (missing_name != NULL)
2748  pg_fatal("table \"%s\" not found", missing_name);
2749  }
2750 
2751  if (ropt->indexNames.head != NULL)
2752  {
2753  missing_name = simple_string_list_not_touched(&ropt->indexNames);
2754  if (missing_name != NULL)
2755  pg_fatal("index \"%s\" not found", missing_name);
2756  }
2757 
2758  if (ropt->functionNames.head != NULL)
2759  {
2760  missing_name = simple_string_list_not_touched(&ropt->functionNames);
2761  if (missing_name != NULL)
2762  pg_fatal("function \"%s\" not found", missing_name);
2763  }
2764 
2765  if (ropt->triggerNames.head != NULL)
2766  {
2767  missing_name = simple_string_list_not_touched(&ropt->triggerNames);
2768  if (missing_name != NULL)
2769  pg_fatal("trigger \"%s\" not found", missing_name);
2770  }
2771 }
2772 
2773 /*
2774  * Determine whether we want to restore this TOC entry.
2775  *
2776  * Returns 0 if entry should be skipped, or some combination of the
2777  * REQ_SCHEMA and REQ_DATA bits if we want to restore schema and/or data
2778  * portions of this TOC entry, or REQ_SPECIAL if it's a special entry.
2779  */
2780 static int
2781 _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
2782 {
2783  int res = REQ_SCHEMA | REQ_DATA;
2784  RestoreOptions *ropt = AH->public.ropt;
2785 
2786  /* These items are treated specially */
2787  if (strcmp(te->desc, "ENCODING") == 0 ||
2788  strcmp(te->desc, "STDSTRINGS") == 0 ||
2789  strcmp(te->desc, "SEARCHPATH") == 0)
2790  return REQ_SPECIAL;
2791 
2792  /*
2793  * DATABASE and DATABASE PROPERTIES also have a special rule: they are
2794  * restored in createDB mode, and not restored otherwise, independently of
2795  * all else.
2796  */
2797  if (strcmp(te->desc, "DATABASE") == 0 ||
2798  strcmp(te->desc, "DATABASE PROPERTIES") == 0)
2799  {
2800  if (ropt->createDB)
2801  return REQ_SCHEMA;
2802  else
2803  return 0;
2804  }
2805 
2806  /*
2807  * Process exclusions that affect certain classes of TOC entries.
2808  */
2809 
2810  /* If it's an ACL, maybe ignore it */
2811  if (ropt->aclsSkip && _tocEntryIsACL(te))
2812  return 0;
2813 
2814  /* If it's a comment, maybe ignore it */
2815  if (ropt->no_comments && strcmp(te->desc, "COMMENT") == 0)
2816  return 0;
2817 
2818  /*
2819  * If it's a publication or a table part of a publication, maybe ignore
2820  * it.
2821  */
2822  if (ropt->no_publications &&
2823  (strcmp(te->desc, "PUBLICATION") == 0 ||
2824  strcmp(te->desc, "PUBLICATION TABLE") == 0 ||
2825  strcmp(te->desc, "PUBLICATION TABLES IN SCHEMA") == 0))
2826  return 0;
2827 
2828  /* If it's a security label, maybe ignore it */
2829  if (ropt->no_security_labels && strcmp(te->desc, "SECURITY LABEL") == 0)
2830  return 0;
2831 
2832  /* If it's a subscription, maybe ignore it */
2833  if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
2834  return 0;
2835 
2836  /* Ignore it if section is not to be dumped/restored */
2837  switch (curSection)
2838  {
2839  case SECTION_PRE_DATA:
2840  if (!(ropt->dumpSections & DUMP_PRE_DATA))
2841  return 0;
2842  break;
2843  case SECTION_DATA:
2844  if (!(ropt->dumpSections & DUMP_DATA))
2845  return 0;
2846  break;
2847  case SECTION_POST_DATA:
2848  if (!(ropt->dumpSections & DUMP_POST_DATA))
2849  return 0;
2850  break;
2851  default:
2852  /* shouldn't get here, really, but ignore it */
2853  return 0;
2854  }
2855 
2856  /* Ignore it if rejected by idWanted[] (cf. SortTocFromFile) */
2857  if (ropt->idWanted && !ropt->idWanted[te->dumpId - 1])
2858  return 0;
2859 
2860  /*
2861  * Check options for selective dump/restore.
2862  */
2863  if (strcmp(te->desc, "ACL") == 0 ||
2864  strcmp(te->desc, "COMMENT") == 0 ||
2865  strcmp(te->desc, "SECURITY LABEL") == 0)
2866  {
2867  /* Database properties react to createDB, not selectivity options. */
2868  if (strncmp(te->tag, "DATABASE ", 9) == 0)
2869  {
2870  if (!ropt->createDB)
2871  return 0;
2872  }
2873  else if (ropt->schemaNames.head != NULL ||
2874  ropt->schemaExcludeNames.head != NULL ||
2875  ropt->selTypes)
2876  {
2877  /*
2878  * In a selective dump/restore, we want to restore these dependent
2879  * TOC entry types only if their parent object is being restored.
2880  * Without selectivity options, we let through everything in the
2881  * archive. Note there may be such entries with no parent, eg
2882  * non-default ACLs for built-in objects.
2883  *
2884  * This code depends on the parent having been marked already,
2885  * which should be the case; if it isn't, perhaps due to
2886  * SortTocFromFile rearrangement, skipping the dependent entry
2887  * seems prudent anyway.
2888  *
2889  * Ideally we'd handle, eg, table CHECK constraints this way too.
2890  * But it's hard to tell which of their dependencies is the one to
2891  * consult.
2892  */
2893  if (te->nDeps != 1 ||
2894  TocIDRequired(AH, te->dependencies[0]) == 0)
2895  return 0;
2896  }
2897  }
2898  else
2899  {
2900  /* Apply selective-restore rules for standalone TOC entries. */
2901  if (ropt->schemaNames.head != NULL)
2902  {
2903  /* If no namespace is specified, it means all. */
2904  if (!te->namespace)
2905  return 0;
2906  if (!simple_string_list_member(&ropt->schemaNames, te->namespace))
2907  return 0;
2908  }
2909 
2910  if (ropt->schemaExcludeNames.head != NULL &&
2911  te->namespace &&
2912  simple_string_list_member(&ropt->schemaExcludeNames, te->namespace))
2913  return 0;
2914 
2915  if (ropt->selTypes)
2916  {
2917  if (strcmp(te->desc, "TABLE") == 0 ||
2918  strcmp(te->desc, "TABLE DATA") == 0 ||
2919  strcmp(te->desc, "VIEW") == 0 ||
2920  strcmp(te->desc, "FOREIGN TABLE") == 0 ||
2921  strcmp(te->desc, "MATERIALIZED VIEW") == 0 ||
2922  strcmp(te->desc, "MATERIALIZED VIEW DATA") == 0 ||
2923  strcmp(te->desc, "SEQUENCE") == 0 ||
2924  strcmp(te->desc, "SEQUENCE SET") == 0)
2925  {
2926  if (!ropt->selTable)
2927  return 0;
2928  if (ropt->tableNames.head != NULL &&
2929  !simple_string_list_member(&ropt->tableNames, te->tag))
2930  return 0;
2931  }
2932  else if (strcmp(te->desc, "INDEX") == 0)
2933  {
2934  if (!ropt->selIndex)
2935  return 0;
2936  if (ropt->indexNames.head != NULL &&
2937  !simple_string_list_member(&ropt->indexNames, te->tag))
2938  return 0;
2939  }
2940  else if (strcmp(te->desc, "FUNCTION") == 0 ||
2941  strcmp(te->desc, "AGGREGATE") == 0 ||
2942  strcmp(te->desc, "PROCEDURE") == 0)
2943  {
2944  if (!ropt->selFunction)
2945  return 0;
2946  if (ropt->functionNames.head != NULL &&
2947  !simple_string_list_member(&ropt->functionNames, te->tag))
2948  return 0;
2949  }
2950  else if (strcmp(te->desc, "TRIGGER") == 0)
2951  {
2952  if (!ropt->selTrigger)
2953  return 0;
2954  if (ropt->triggerNames.head != NULL &&
2955  !simple_string_list_member(&ropt->triggerNames, te->tag))
2956  return 0;
2957  }
2958  else
2959  return 0;
2960  }
2961  }
2962 
2963  /*
2964  * Determine whether the TOC entry contains schema and/or data components,
2965  * and mask off inapplicable REQ bits. If it had a dataDumper, assume
2966  * it's both schema and data. Otherwise it's probably schema-only, but
2967  * there are exceptions.
2968  */
2969  if (!te->hadDumper)
2970  {
2971  /*
2972  * Special Case: If 'SEQUENCE SET' or anything to do with LOs, then it
2973  * is considered a data entry. We don't need to check for the BLOBS
2974  * entry or old-style BLOB COMMENTS, because they will have hadDumper
2975  * = true ... but we do need to check new-style BLOB ACLs, comments,
2976  * etc.
2977  */
2978  if (strcmp(te->desc, "SEQUENCE SET") == 0 ||
2979  strcmp(te->desc, "BLOB") == 0 ||
2980  (strcmp(te->desc, "ACL") == 0 &&
2981  strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
2982  (strcmp(te->desc, "COMMENT") == 0 &&
2983  strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
2984  (strcmp(te->desc, "SECURITY LABEL") == 0 &&
2985  strncmp(te->tag, "LARGE OBJECT ", 13) == 0))
2986  res = res & REQ_DATA;
2987  else
2988  res = res & ~REQ_DATA;
2989  }
2990 
2991  /*
2992  * If there's no definition command, there's no schema component. Treat
2993  * "load via partition root" comments as not schema.
2994  */
2995  if (!te->defn || !te->defn[0] ||
2996  strncmp(te->defn, "-- load via partition root ", 27) == 0)
2997  res = res & ~REQ_SCHEMA;
2998 
2999  /*
3000  * Special case: <Init> type with <Max OID> tag; this is obsolete and we
3001  * always ignore it.
3002  */
3003  if ((strcmp(te->desc, "<Init>") == 0) && (strcmp(te->tag, "Max OID") == 0))
3004  return 0;
3005 
3006  /* Mask it if we only want schema */
3007  if (ropt->schemaOnly)
3008  {
3009  /*
3010  * The sequence_data option overrides schemaOnly for SEQUENCE SET.
3011  *
3012  * In binary-upgrade mode, even with schemaOnly set, we do not mask
3013  * out large objects. (Only large object definitions, comments and
3014  * other metadata should be generated in binary-upgrade mode, not the
3015  * actual data, but that need not concern us here.)
3016  */
3017  if (!(ropt->sequence_data && strcmp(te->desc, "SEQUENCE SET") == 0) &&
3018  !(ropt->binary_upgrade &&
3019  (strcmp(te->desc, "BLOB") == 0 ||
3020  (strcmp(te->desc, "ACL") == 0 &&
3021  strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
3022  (strcmp(te->desc, "COMMENT") == 0 &&
3023  strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
3024  (strcmp(te->desc, "SECURITY LABEL") == 0 &&
3025  strncmp(te->tag, "LARGE OBJECT ", 13) == 0))))
3026  res = res & REQ_SCHEMA;
3027  }
3028 
3029  /* Mask it if we only want data */
3030  if (ropt->dataOnly)
3031  res = res & REQ_DATA;
3032 
3033  return res;
3034 }
3035 
3036 /*
3037  * Identify which pass we should restore this TOC entry in.
3038  *
3039  * See notes with the RestorePass typedef in pg_backup_archiver.h.
3040  */
3041 static RestorePass
3042 _tocEntryRestorePass(TocEntry *te)
3043 {
3044  /* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */
3045  if (strcmp(te->desc, "ACL") == 0 ||
3046  strcmp(te->desc, "ACL LANGUAGE") == 0 ||
3047  strcmp(te->desc, "DEFAULT ACL") == 0)
3048  return RESTORE_PASS_ACL;
3049  if (strcmp(te->desc, "EVENT TRIGGER") == 0 ||
3050  strcmp(te->desc, "MATERIALIZED VIEW DATA") == 0)
3051  return RESTORE_PASS_POST_ACL;
3052 
3053  /*
3054  * Comments need to be emitted in the same pass as their parent objects.
3055  * ACLs haven't got comments, and neither do matview data objects, but
3056  * event triggers do. (Fortunately, event triggers haven't got ACLs, or
3057  * we'd need yet another weird special case.)
3058  */
3059  if (strcmp(te->desc, "COMMENT") == 0 &&
3060  strncmp(te->tag, "EVENT TRIGGER ", 14) == 0)
3061  return RESTORE_PASS_POST_ACL;
3062 
3063  /* All else can be handled in the main pass. */
3064  return RESTORE_PASS_MAIN;
3065 }
3066 
3067 /*
3068  * Identify TOC entries that are ACLs.
3069  *
3070  * Note: it seems worth duplicating some code here to avoid a hard-wired
3071  * assumption that these are exactly the same entries that we restore during
3072  * the RESTORE_PASS_ACL phase.
3073  */
3074 static bool
3075 _tocEntryIsACL(TocEntry *te)
3076 {
3077  /* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */
3078  if (strcmp(te->desc, "ACL") == 0 ||
3079  strcmp(te->desc, "ACL LANGUAGE") == 0 ||
3080  strcmp(te->desc, "DEFAULT ACL") == 0)
3081  return true;
3082  return false;
3083 }
3084 
3085 /*
3086  * Issue SET commands for parameters that we want to have set the same way
3087  * at all times during execution of a restore script.
3088  */
3089 static void
3090 _doSetFixedOutputState(ArchiveHandle *AH)
3091 {
3092  RestoreOptions *ropt = AH->public.ropt;
3093 
3094  /*
3095  * Disable timeouts to allow for slow commands, idle parallel workers, etc
3096  */
3097  ahprintf(AH, "SET statement_timeout = 0;\n");
3098  ahprintf(AH, "SET lock_timeout = 0;\n");
3099  ahprintf(AH, "SET idle_in_transaction_session_timeout = 0;\n");
3100 
3101  /* Select the correct character set encoding */
3102  ahprintf(AH, "SET client_encoding = '%s';\n",
3103  pg_encoding_to_char(AH->public.encoding));
3104 
3105  /* Select the correct string literal syntax */
3106  ahprintf(AH, "SET standard_conforming_strings = %s;\n",
3107  AH->public.std_strings ? "on" : "off");
3108 
3109  /* Select the role to be used during restore */
3110  if (ropt && ropt->use_role)
3111  ahprintf(AH, "SET ROLE %s;\n", fmtId(ropt->use_role));
3112 
3113  /* Select the dump-time search_path */
3114  if (AH->public.searchpath)
3115  ahprintf(AH, "%s", AH->public.searchpath);
3116 
3117  /* Make sure function checking is disabled */
3118  ahprintf(AH, "SET check_function_bodies = false;\n");
3119 
3120  /* Ensure that all valid XML data will be accepted */
3121  ahprintf(AH, "SET xmloption = content;\n");
3122 
3123  /* Avoid annoying notices etc */
3124  ahprintf(AH, "SET client_min_messages = warning;\n");
3125  if (!AH->public.std_strings)
3126  ahprintf(AH, "SET escape_string_warning = off;\n");
3127 
3128  /* Adjust row-security state */
3129  if (ropt && ropt->enable_row_security)
3130  ahprintf(AH, "SET row_security = on;\n");
3131  else
3132  ahprintf(AH, "SET row_security = off;\n");
3133 
3134  ahprintf(AH, "\n");
3135 }
3136 
3137 /*
3138  * Issue a SET SESSION AUTHORIZATION command. Caller is responsible
3139  * for updating state if appropriate. If user is NULL or an empty string,
3140  * the specification DEFAULT will be used.
3141  */
3142 static void
3143 _doSetSessionAuth(ArchiveHandle *AH, const char *user)
3144 {
3145  PQExpBuffer cmd = createPQExpBuffer();
3146 
3147  appendPQExpBufferStr(cmd, "SET SESSION AUTHORIZATION ");
3148 
3149  /*
3150  * SQL requires a string literal here. Might as well be correct.
3151  */
3152  if (user && *user)
3153  appendStringLiteralAHX(cmd, user, AH);
3154  else
3155  appendPQExpBufferStr(cmd, "DEFAULT");
3156  appendPQExpBufferChar(cmd, ';');
3157 
3158  if (RestoringToDB(AH))
3159  {
3160  PGresult *res;
3161 
3162  res = PQexec(AH->connection, cmd->data);
3163 
3164  if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
3165  /* NOT warn_or_exit_horribly... use -O instead to skip this. */
3166  pg_fatal("could not set session user to \"%s\": %s",
3167  user, PQerrorMessage(AH->connection));
3168 
3169  PQclear(res);
3170  }
3171  else
3172  ahprintf(AH, "%s\n\n", cmd->data);
3173 
3174  destroyPQExpBuffer(cmd);
3175 }
3176 
3177 
3178 /*
3179  * Issue the commands to connect to the specified database.
3180  *
3181  * If we're currently restoring right into a database, this will
3182  * actually establish a connection. Otherwise it puts a \connect into
3183  * the script output.
3184  */
3185 static void
3186 _reconnectToDB(ArchiveHandle *AH, const char *dbname)
3187 {
3188  if (RestoringToDB(AH))
3189  ReconnectToServer(AH, dbname);
3190  else
3191  {
3192  PQExpBufferData connectbuf;
3193 
3194  initPQExpBuffer(&connectbuf);
3195  appendPsqlMetaConnect(&connectbuf, dbname);
3196  ahprintf(AH, "%s\n", connectbuf.data);
3197  termPQExpBuffer(&connectbuf);
3198  }
3199 
3200  /*
3201  * NOTE: currUser keeps track of what the imaginary session user in our
3202  * script is. It's now effectively reset to the original userID.
3203  */
3204  free(AH->currUser);
3205  AH->currUser = NULL;
3206 
3207  /* don't assume we still know the output schema, tablespace, etc either */
3208  free(AH->currSchema);
3209  AH->currSchema = NULL;
3210 
3211  free(AH->currTableAm);
3212  AH->currTableAm = NULL;
3213 
3214  free(AH->currTablespace);
3215  AH->currTablespace = NULL;
3216 
3217  /* re-establish fixed state */
3218  _doSetFixedOutputState(AH);
3219 }
3220 
3221 /*
3222  * Become the specified user, and update state to avoid redundant commands
3223  *
3224  * NULL or empty argument is taken to mean restoring the session default
3225  */
3226 static void
3227 _becomeUser(ArchiveHandle *AH, const char *user)
3228 {
3229  if (!user)
3230  user = ""; /* avoid null pointers */
3231 
3232  if (AH->currUser && strcmp(AH->currUser, user) == 0)
3233  return; /* no need to do anything */
3234 
3235  _doSetSessionAuth(AH, user);
3236 
3237  /*
3238  * NOTE: currUser keeps track of what the imaginary session user in our
3239  * script is
3240  */
3241  free(AH->currUser);
3242  AH->currUser = pg_strdup(user);
3243 }
3244 
3245 /*
3246  * Become the owner of the given TOC entry object. If
3247  * changes in ownership are not allowed, this doesn't do anything.
3248  */
3249 static void
3250 _becomeOwner(ArchiveHandle *AH, TocEntry *te)
3251 {
3252  RestoreOptions *ropt = AH->public.ropt;
3253 
3254  if (ropt && (ropt->noOwner || !ropt->use_setsessauth))
3255  return;
3256 
3257  _becomeUser(AH, te->owner);
3258 }
3259 
3260 
3261 /*
3262  * Issue the commands to select the specified schema as the current schema
3263  * in the target database.
3264  */
3265 static void
3266 _selectOutputSchema(ArchiveHandle *AH, const char *schemaName)
3267 {
3268  PQExpBuffer qry;
3269 
3270  /*
3271  * If there was a SEARCHPATH TOC entry, we're supposed to just stay with
3272  * that search_path rather than switching to entry-specific paths.
3273  * Otherwise, it's an old archive that will not restore correctly unless
3274  * we set the search_path as it's expecting.
3275  */
3276  if (AH->public.searchpath)
3277  return;
3278 
3279  if (!schemaName || *schemaName == '\0' ||
3280  (AH->currSchema && strcmp(AH->currSchema, schemaName) == 0))
3281  return; /* no need to do anything */
3282 
3283  qry = createPQExpBuffer();
3284 
3285  appendPQExpBuffer(qry, "SET search_path = %s",
3286  fmtId(schemaName));
3287  if (strcmp(schemaName, "pg_catalog") != 0)
3288  appendPQExpBufferStr(qry, ", pg_catalog");
3289 
3290  if (RestoringToDB(AH))
3291  {
3292  PGresult *res;
3293 
3294  res = PQexec(AH->connection, qry->data);
3295 
3296  if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
3297  warn_or_exit_horribly(AH,
3298  "could not set search_path to \"%s\": %s",
3299  schemaName, PQerrorMessage(AH->connection));
3300 
3301  PQclear(res);
3302  }
3303  else
3304  ahprintf(AH, "%s;\n\n", qry->data);
3305 
3306  free(AH->currSchema);
3307  AH->currSchema = pg_strdup(schemaName);
3308 
3309  destroyPQExpBuffer(qry);
3310 }
3311 
3312 /*
3313  * Issue the commands to select the specified tablespace as the current one
3314  * in the target database.
3315  */
3316 static void
3317 _selectTablespace(ArchiveHandle *AH, const char *tablespace)
3318 {
3319  RestoreOptions *ropt = AH->public.ropt;
3320  PQExpBuffer qry;
3321  const char *want,
3322  *have;
3323 
3324  /* do nothing in --no-tablespaces mode */
3325  if (ropt->noTablespace)
3326  return;
3327 
3328  have = AH->currTablespace;
3329  want = tablespace;
3330 
3331  /* no need to do anything for non-tablespace object */
3332  if (!want)
3333  return;
3334 
3335  if (have && strcmp(want, have) == 0)
3336  return; /* no need to do anything */
3337 
3338  qry = createPQExpBuffer();
3339 
3340  if (strcmp(want, "") == 0)
3341  {
3342  /* We want the tablespace to be the database's default */
3343  appendPQExpBufferStr(qry, "SET default_tablespace = ''");
3344  }
3345  else
3346  {
3347  /* We want an explicit tablespace */
3348  appendPQExpBuffer(qry, "SET default_tablespace = %s", fmtId(want));
3349  }
3350 
3351  if (RestoringToDB(AH))
3352  {
3353  PGresult *res;
3354 
3355  res = PQexec(AH->connection, qry->data);
3356 
3357  if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
3358  warn_or_exit_horribly(AH,
3359  "could not set default_tablespace to %s: %s",
3360  fmtId(want), PQerrorMessage(AH->connection));
3361 
3362  PQclear(res);
3363  }
3364  else
3365  ahprintf(AH, "%s;\n\n", qry->data);
3366 
3367  free(AH->currTablespace);
3368  AH->currTablespace = pg_strdup(want);
3369 
3370  destroyPQExpBuffer(qry);
3371 }
3372 
3373 /*
3374  * Set the proper default_table_access_method value for the table.
3375  */
3376 static void
3377 _selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
3378 {
3379  RestoreOptions *ropt = AH->public.ropt;
3380  PQExpBuffer cmd;
3381  const char *want,
3382  *have;
3383 
3384  /* do nothing in --no-table-access-method mode */
3385  if (ropt->noTableAm)
3386  return;
3387 
3388  have = AH->currTableAm;
3389  want = tableam;
3390 
3391  if (!want)
3392  return;
3393 
3394  if (have && strcmp(want, have) == 0)
3395  return;
3396 
3397  cmd = createPQExpBuffer();
3398  appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", fmtId(want));
3399 
3400  if (RestoringToDB(AH))
3401  {
3402  PGresult *res;
3403 
3404  res = PQexec(AH->connection, cmd->data);
3405 
3406  if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
3407  warn_or_exit_horribly(AH,
3408  "could not set default_table_access_method: %s",
3409  PQerrorMessage(AH->connection));
3410 
3411  PQclear(res);
3412  }
3413  else
3414  ahprintf(AH, "%s\n\n", cmd->data);
3415 
3416  destroyPQExpBuffer(cmd);
3417 
3418  free(AH->currTableAm);
3419  AH->currTableAm = pg_strdup(want);
3420 }
3421 
3422 /*
3423  * Extract an object description for a TOC entry, and append it to buf.
3424  *
3425  * This is used for ALTER ... OWNER TO.
3426  *
3427  * If the object type has no owner, do nothing.
3428  */
3429 static void
3430 _getObjectDescription(PQExpBuffer buf, const TocEntry *te)
3431 {
3432  const char *type = te->desc;
3433 
3434  /* objects that don't require special decoration */
3435  if (strcmp(type, "COLLATION") == 0 ||
3436  strcmp(type, "CONVERSION") == 0 ||
3437  strcmp(type, "DOMAIN") == 0 ||
3438  strcmp(type, "FOREIGN TABLE") == 0 ||
3439  strcmp(type, "MATERIALIZED VIEW") == 0 ||
3440  strcmp(type, "SEQUENCE") == 0 ||
3441  strcmp(type, "STATISTICS") == 0 ||
3442  strcmp(type, "TABLE") == 0 ||
3443  strcmp(type, "TEXT SEARCH DICTIONARY") == 0 ||
3444  strcmp(type, "TEXT SEARCH CONFIGURATION") == 0 ||
3445  strcmp(type, "TYPE") == 0 ||
3446  strcmp(type, "VIEW") == 0 ||
3447  /* non-schema-specified objects */
3448  strcmp(type, "DATABASE") == 0 ||
3449  strcmp(type, "PROCEDURAL LANGUAGE") == 0 ||
3450  strcmp(type, "SCHEMA") == 0 ||
3451  strcmp(type, "EVENT TRIGGER") == 0 ||
3452  strcmp(type, "FOREIGN DATA WRAPPER") == 0 ||
3453  strcmp(type, "SERVER") == 0 ||
3454  strcmp(type, "PUBLICATION") == 0 ||
3455  strcmp(type, "SUBSCRIPTION") == 0)
3456  {
3457  appendPQExpBuffer(buf, "%s ", type);
3458  if (te->namespace && *te->namespace)
3459  appendPQExpBuffer(buf, "%s.", fmtId(te->namespace));
3460  appendPQExpBufferStr(buf, fmtId(te->tag));
3461  }
3462  /* LOs just have a name, but it's numeric so must not use fmtId */
3463  else if (strcmp(type, "BLOB") == 0)
3464  {
3465  appendPQExpBuffer(buf, "LARGE OBJECT %s", te->tag);
3466  }
3467 
3468  /*
3469  * These object types require additional decoration. Fortunately, the
3470  * information needed is exactly what's in the DROP command.
3471  */
3472  else if (strcmp(type, "AGGREGATE") == 0 ||
3473  strcmp(type, "FUNCTION") == 0 ||
3474  strcmp(type, "OPERATOR") == 0 ||
3475  strcmp(type, "OPERATOR CLASS") == 0 ||
3476  strcmp(type, "OPERATOR FAMILY") == 0 ||
3477  strcmp(type, "PROCEDURE") == 0)
3478  {
3479  /* Chop "DROP " off the front and make a modifiable copy */
3480  char *first = pg_strdup(te->dropStmt + 5);
3481  char *last;
3482 
3483  /* point to last character in string */
3484  last = first + strlen(first) - 1;
3485 
3486  /* Strip off any ';' or '\n' at the end */
3487  while (last >= first && (*last == '\n' || *last == ';'))
3488  last--;
3489  *(last + 1) = '\0';
3490 
3491  appendPQExpBufferStr(buf, first);
3492 
3493  free(first);
3494  return;
3495  }
3496  /* these object types don't have separate owners */
3497  else if (strcmp(type, "CAST") == 0 ||
3498  strcmp(type, "CHECK CONSTRAINT") == 0 ||
3499  strcmp(type, "CONSTRAINT") == 0 ||
3500  strcmp(type, "DATABASE PROPERTIES") == 0 ||
3501  strcmp(type, "DEFAULT") == 0 ||
3502  strcmp(type, "FK CONSTRAINT") == 0 ||
3503  strcmp(type, "INDEX") == 0 ||
3504  strcmp(type, "RULE") == 0 ||
3505  strcmp(type, "TRIGGER") == 0 ||
3506  strcmp(type, "ROW SECURITY") == 0 ||
3507  strcmp(type, "POLICY") == 0 ||
3508  strcmp(type, "USER MAPPING") == 0)
3509  {
3510  /* do nothing */
3511  }
3512  else
3513  pg_fatal("don't know how to set owner for object type \"%s\"", type);
3514 }
3515 
3516 /*
3517  * Emit the SQL commands to create the object represented by a TOC entry
3518  *
3519  * This now also includes issuing an ALTER OWNER command to restore the
3520  * object's ownership, if wanted. But note that the object's permissions
3521  * will remain at default, until the matching ACL TOC entry is restored.
3522  */
3523 static void
3524 _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
3525 {
3526  RestoreOptions *ropt = AH->public.ropt;
3527 
3528  /* Select owner, schema, tablespace and default AM as necessary */
3529  _becomeOwner(AH, te);
3530  _selectOutputSchema(AH, te->namespace);
3531  _selectTablespace(AH, te->tablespace);
3532  _selectTableAccessMethod(AH, te->tableam);
3533 
3534  /* Emit header comment for item */
3535  if (!AH->noTocComments)
3536  {
3537  const char *pfx;
3538  char *sanitized_name;
3539  char *sanitized_schema;
3540  char *sanitized_owner;
3541 
3542  if (isData)
3543  pfx = "Data for ";
3544  else
3545  pfx = "";
3546 
3547  ahprintf(AH, "--\n");
3548  if (AH->public.verbose)
3549  {
3550  ahprintf(AH, "-- TOC entry %d (class %u OID %u)\n",
3551  te->dumpId, te->catalogId.tableoid, te->catalogId.oid);
3552  if (te->nDeps > 0)
3553  {
3554  int i;
3555 
3556  ahprintf(AH, "-- Dependencies:");
3557  for (i = 0; i < te->nDeps; i++)
3558  ahprintf(AH, " %d", te->dependencies[i]);
3559  ahprintf(AH, "\n");
3560  }
3561  }
3562 
3563  sanitized_name = sanitize_line(te->tag, false);
3564  sanitized_schema = sanitize_line(te->namespace, true);
3565  sanitized_owner = sanitize_line(ropt->noOwner ? NULL : te->owner, true);
3566 
3567  ahprintf(AH, "-- %sName: %s; Type: %s; Schema: %s; Owner: %s",
3568  pfx, sanitized_name, te->desc, sanitized_schema,
3569  sanitized_owner);
3570 
3571  free(sanitized_name);
3572  free(sanitized_schema);
3573  free(sanitized_owner);
3574 
3575  if (te->tablespace && strlen(te->tablespace) > 0 && !ropt->noTablespace)
3576  {
3577  char *sanitized_tablespace;
3578 
3579  sanitized_tablespace = sanitize_line(te->tablespace, false);
3580  ahprintf(AH, "; Tablespace: %s", sanitized_tablespace);
3581  free(sanitized_tablespace);
3582  }
3583  ahprintf(AH, "\n");
3584 
3585  if (AH->PrintExtraTocPtr != NULL)
3586  AH->PrintExtraTocPtr(AH, te);
3587  ahprintf(AH, "--\n\n");
3588  }
3589 
3590  /*
3591  * Actually print the definition.
3592  *
3593  * Really crude hack for suppressing AUTHORIZATION clause that old pg_dump
3594  * versions put into CREATE SCHEMA. Don't mutate the variant for schema
3595  * "public" that is a comment. We have to do this when --no-owner mode is
3596  * selected. This is ugly, but I see no other good way ...
3597  */
3598  if (ropt->noOwner &&
3599  strcmp(te->desc, "SCHEMA") == 0 && strncmp(te->defn, "--", 2) != 0)
3600  {
3601  ahprintf(AH, "CREATE SCHEMA %s;\n\n\n", fmtId(te->tag));
3602  }
3603  else
3604  {
3605  if (te->defn && strlen(te->defn) > 0)
3606  ahprintf(AH, "%s\n\n", te->defn);
3607  }
3608 
3609  /*
3610  * If we aren't using SET SESSION AUTH to determine ownership, we must
3611  * instead issue an ALTER OWNER command. Schema "public" is special; when
3612  * a dump emits a comment in lieu of creating it, we use ALTER OWNER even
3613  * when using SET SESSION for all other objects. We assume that anything
3614  * without a DROP command is not a separately ownable object.
3615  */
3616  if (!ropt->noOwner &&
3617  (!ropt->use_setsessauth ||
3618  (strcmp(te->desc, "SCHEMA") == 0 &&
3619  strncmp(te->defn, "--", 2) == 0)) &&
3620  te->owner && strlen(te->owner) > 0 &&
3621  te->dropStmt && strlen(te->dropStmt) > 0)
3622  {
3623  PQExpBufferData temp;
3624 
3625  initPQExpBuffer(&temp);
3626  _getObjectDescription(&temp, te);
3627 
3628  /*
3629  * If _getObjectDescription() didn't fill the buffer, then there is no
3630  * owner.
3631  */
3632  if (temp.data[0])
3633  ahprintf(AH, "ALTER %s OWNER TO %s;\n\n", temp.data, fmtId(te->owner));
3634  termPQExpBuffer(&temp);
3635  }
3636 
3637  /*
3638  * If it's an ACL entry, it might contain SET SESSION AUTHORIZATION
3639  * commands, so we can no longer assume we know the current auth setting.
3640  */
3641  if (_tocEntryIsACL(te))
3642  {
3643  free(AH->currUser);
3644  AH->currUser = NULL;
3645  }
3646 }
3647 
3648 /*
3649  * Sanitize a string to be included in an SQL comment or TOC listing, by
3650  * replacing any newlines with spaces. This ensures each logical output line
3651  * is in fact one physical output line, to prevent corruption of the dump
3652  * (which could, in the worst case, present an SQL injection vulnerability
3653  * if someone were to incautiously load a dump containing objects with
3654  * maliciously crafted names).
3655  *
3656  * The result is a freshly malloc'd string. If the input string is NULL,
3657  * return a malloc'ed empty string, unless want_hyphen, in which case return a
3658  * malloc'ed hyphen.
3659  *
3660  * Note that we currently don't bother to quote names, meaning that the name
3661  * fields aren't automatically parseable. "pg_restore -L" doesn't care because
3662  * it only examines the dumpId field, but someday we might want to try harder.
3663  */
3664 static char *
3665 sanitize_line(const char *str, bool want_hyphen)
3666 {
3667  char *result;
3668  char *s;
3669 
3670  if (!str)
3671  return pg_strdup(want_hyphen ? "-" : "");
3672 
3673  result = pg_strdup(str);
3674 
3675  for (s = result; *s != '\0'; s++)
3676  {
3677  if (*s == '\n' || *s == '\r')
3678  *s = ' ';
3679  }
3680 
3681  return result;
3682 }
3683 
3684 /*
3685  * Write the file header for a custom-format archive
3686  */
3687 void
3688 WriteHead(ArchiveHandle *AH)
3689 {
3690  struct tm crtm;
3691 
3692  AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
3693  AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
3694  AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
3695  AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
3696  AH->WriteBytePtr(AH, AH->intSize);
3697  AH->WriteBytePtr(AH, AH->offSize);
3698  AH->WriteBytePtr(AH, AH->format);
3699  AH->WriteBytePtr(AH, AH->compression_spec.algorithm);
3700  crtm = *localtime(&AH->createDate);
3701  WriteInt(AH, crtm.tm_sec);
3702  WriteInt(AH, crtm.tm_min);
3703  WriteInt(AH, crtm.tm_hour);
3704  WriteInt(AH, crtm.tm_mday);
3705  WriteInt(AH, crtm.tm_mon);
3706  WriteInt(AH, crtm.tm_year);
3707  WriteInt(AH, crtm.tm_isdst);
3708  WriteStr(AH, PQdb(AH->connection));
3709  WriteStr(AH, AH->public.remoteVersionStr);
3710  WriteStr(AH, PG_VERSION);
3711 }
3712 
3713 void
3714 ReadHead(ArchiveHandle *AH)
3715 {
3716  char *errmsg;
3717  char vmaj,
3718  vmin,
3719  vrev;
3720  int fmt;
3721 
3722  /*
3723  * If we haven't already read the header, do so.
3724  *
3725  * NB: this code must agree with _discoverArchiveFormat(). Maybe find a
3726  * way to unify the cases?
3727  */
3728  if (!AH->readHeader)
3729  {
3730  char tmpMag[7];
3731 
3732  AH->ReadBufPtr(AH, tmpMag, 5);
3733 
3734  if (strncmp(tmpMag, "PGDMP", 5) != 0)
3735  pg_fatal("did not find magic string in file header");
3736  }
3737 
3738  vmaj = AH->ReadBytePtr(AH);
3739  vmin = AH->ReadBytePtr(AH);
3740 
3741  if (vmaj > 1 || (vmaj == 1 && vmin > 0)) /* Version > 1.0 */
3742  vrev = AH->ReadBytePtr(AH);
3743  else
3744  vrev = 0;
3745 
3746  AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
3747 
3748  if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
3749  pg_fatal("unsupported version (%d.%d) in file header",
3750  vmaj, vmin);
3751 
3752  AH->intSize = AH->ReadBytePtr(AH);
3753  if (AH->intSize > 32)
3754  pg_fatal("sanity check on integer size (%lu) failed",
3755  (unsigned long) AH->intSize);
3756 
3757  if (AH->intSize > sizeof(int))
3758  pg_log_warning("archive was made on a machine with larger integers, some operations might fail");
3759 
3760  if (AH->version >= K_VERS_1_7)
3761  AH->offSize = AH->ReadBytePtr(AH);
3762  else
3763  AH->offSize = AH->intSize;
3764 
3765  fmt = AH->ReadBytePtr(AH);
3766 
3767  if (AH->format != fmt)
3768  pg_fatal("expected format (%d) differs from format found in file (%d)",
3769  AH->format, fmt);
3770 
3771  if (AH->version >= K_VERS_1_15)
3772  AH->compression_spec.algorithm = AH->ReadBytePtr(AH);
3773  else if (AH->version >= K_VERS_1_2)
3774  {
3775  /* Guess the compression method based on the level */
3776  if (AH->version < K_VERS_1_4)
3777  AH->compression_spec.level = AH->ReadBytePtr(AH);
3778  else
3779  AH->compression_spec.level = ReadInt(AH);
3780 
3781  if (AH->compression_spec.level != 0)
3782  AH->compression_spec.algorithm = PG_COMPRESSION_GZIP;
3783  }
3784  else
3785  AH->compression_spec.algorithm = PG_COMPRESSION_GZIP;
3786 
3787  errmsg = supports_compression(AH->compression_spec);
3788  if (errmsg)
3789  {
3790  pg_log_warning("archive is compressed, but this installation does not support compression (%s) -- no data will be available",
3791  errmsg);
3792  pg_free(errmsg);
3793  }
3794 
3795  if (AH->version >= K_VERS_1_4)
3796  {
3797  struct tm crtm;
3798 
3799  crtm.tm_sec = ReadInt(AH);
3800  crtm.tm_min = ReadInt(AH);
3801  crtm.tm_hour = ReadInt(AH);
3802  crtm.tm_mday = ReadInt(AH);
3803  crtm.tm_mon = ReadInt(AH);
3804  crtm.tm_year = ReadInt(AH);
3805  crtm.tm_isdst = ReadInt(AH);
3806 
3807  /*
3808  * Newer versions of glibc have mktime() report failure if tm_isdst is
3809  * inconsistent with the prevailing timezone, e.g. tm_isdst = 1 when
3810  * TZ=UTC. This is problematic when restoring an archive under a
3811  * different timezone setting. If we get a failure, try again with
3812  * tm_isdst set to -1 ("don't know").
3813  *
3814  * XXX with or without this hack, we reconstruct createDate
3815  * incorrectly when the prevailing timezone is different from
3816  * pg_dump's. Next time we bump the archive version, we should flush
3817  * this representation and store a plain seconds-since-the-Epoch
3818  * timestamp instead.
3819  */
3820  AH->createDate = mktime(&crtm);
3821  if (AH->createDate == (time_t) -1)
3822  {
3823  crtm.tm_isdst = -1;
3824  AH->createDate = mktime(&crtm);
3825  if (AH->createDate == (time_t) -1)
3826  pg_log_warning("invalid creation date in header");
3827  }
3828  }
3829 
3830  if (AH->version >= K_VERS_1_4)
3831  {
3832  AH->archdbname = ReadStr(AH);
3833  }
3834 
3835  if (AH->version >= K_VERS_1_10)
3836  {
3837  AH->archiveRemoteVersion = ReadStr(AH);
3838  AH->archiveDumpVersion = ReadStr(AH);
3839  }
3840 }
3841 
3842 
3843 /*
3844  * checkSeek
3845  * check to see if ftell/fseek can be performed.
3846  */
3847 bool
3848 checkSeek(FILE *fp)
3849 {
3850  pgoff_t tpos;
3851 
3852  /* Check that ftello works on this file */
3853  tpos = ftello(fp);
3854  if (tpos < 0)
3855  return false;
3856 
3857  /*
3858  * Check that fseeko(SEEK_SET) works, too. NB: we used to try to test
3859  * this with fseeko(fp, 0, SEEK_CUR). But some platforms treat that as a
3860  * successful no-op even on files that are otherwise unseekable.
3861  */
3862  if (fseeko(fp, tpos, SEEK_SET) != 0)
3863  return false;
3864 
3865  return true;
3866 }
3867 
3868 
3869 /*
3870  * dumpTimestamp
3871  */
3872 static void
3873 dumpTimestamp(ArchiveHandle *AH, const char *msg, time_t tim)
3874 {
3875  char buf[64];
3876 
3877  if (strftime(buf, sizeof(buf), PGDUMP_STRFTIME_FMT, localtime(&tim)) != 0)
3878  ahprintf(AH, "-- %s %s\n\n", msg, buf);
3879 }
3880 
3881 /*
3882  * Main engine for parallel restore.
3883  *
3884  * Parallel restore is done in three phases. In this first phase,
3885  * we'll process all SECTION_PRE_DATA TOC entries that are allowed to be
3886  * processed in the RESTORE_PASS_MAIN pass. (In practice, that's all
3887  * PRE_DATA items other than ACLs.) Entries we can't process now are
3888  * added to the pending_list for later phases to deal with.
3889  */
3890 static void
3891 restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
3892 {
3893  bool skipped_some;
3894  TocEntry *next_work_item;
3895 
3896  pg_log_debug("entering restore_toc_entries_prefork");
3897 
3898  /* Adjust dependency information */
3899  fix_dependencies(AH);
3900 
3901  /*
3902  * Do all the early stuff in a single connection in the parent. There's no
3903  * great point in running it in parallel, in fact it will actually run
3904  * faster in a single connection because we avoid all the connection and
3905  * setup overhead. Also, pre-9.2 pg_dump versions were not very good
3906  * about showing all the dependencies of SECTION_PRE_DATA items, so we do
3907  * not risk trying to process them out-of-order.
3908  *
3909  * Stuff that we can't do immediately gets added to the pending_list.
3910  * Note: we don't yet filter out entries that aren't going to be restored.
3911  * They might participate in dependency chains connecting entries that
3912  * should be restored, so we treat them as live until we actually process
3913  * them.
3914  *
3915  * Note: as of 9.2, it should be guaranteed that all PRE_DATA items appear
3916  * before DATA items, and all DATA items before POST_DATA items. That is
3917  * not certain to be true in older archives, though, and in any case use
3918  * of a list file would destroy that ordering (cf. SortTocFromFile). So
3919  * this loop cannot assume that it holds.
3920  */
3921  AH->restorePass = RESTORE_PASS_MAIN;
3922  skipped_some = false;
3923  for (next_work_item = AH->toc->next; next_work_item != AH->toc; next_work_item = next_work_item->next)
3924  {
3925  bool do_now = true;
3926 
3927  if (next_work_item->section != SECTION_PRE_DATA)
3928  {
3929  /* DATA and POST_DATA items are just ignored for now */
3930  if (next_work_item->section == SECTION_DATA ||
3931  next_work_item->section == SECTION_POST_DATA)
3932  {
3933  do_now = false;
3934  skipped_some = true;
3935  }
3936  else
3937  {
3938  /*
3939  * SECTION_NONE items, such as comments, can be processed now
3940  * if we are still in the PRE_DATA part of the archive. Once
3941  * we've skipped any items, we have to consider whether the
3942  * comment's dependencies are satisfied, so skip it for now.
3943  */
3944  if (skipped_some)
3945  do_now = false;
3946  }
3947  }
3948 
3949  /*
3950  * Also skip items that need to be forced into later passes. We need
3951  * not set skipped_some in this case, since by assumption no main-pass
3952  * items could depend on these.
3953  */
3954  if (_tocEntryRestorePass(next_work_item) != RESTORE_PASS_MAIN)
3955  do_now = false;
3956 
3957  if (do_now)
3958  {
3959  /* OK, restore the item and update its dependencies */
3960  pg_log_info("processing item %d %s %s",
3961  next_work_item->dumpId,
3962  next_work_item->desc, next_work_item->tag);
3963 
3964  (void) restore_toc_entry(AH, next_work_item, false);
3965 
3966  /* Reduce dependencies, but don't move anything to ready_heap */
3967  reduce_dependencies(AH, next_work_item, NULL);
3968  }
3969  else
3970  {
3971  /* Nope, so add it to pending_list */
3972  pending_list_append(pending_list, next_work_item);
3973  }
3974  }
3975 
3976  /*
3977  * Now close parent connection in prep for parallel steps. We do this
3978  * mainly to ensure that we don't exceed the specified number of parallel
3979  * connections.
3980  */
3981  DisconnectDatabase(&AH->public);
3982 
3983  /* blow away any transient state from the old connection */
3984  free(AH->currUser);
3985  AH->currUser = NULL;
3986  free(AH->currSchema);
3987  AH->currSchema = NULL;
3988  free(AH->currTablespace);
3989  AH->currTablespace = NULL;
3990  free(AH->currTableAm);
3991  AH->currTableAm = NULL;
3992 }
3993 
3994 /*
3995  * Main engine for parallel restore.
3996  *
3997  * Parallel restore is done in three phases. In this second phase,
3998  * we process entries by dispatching them to parallel worker children
3999  * (processes on Unix, threads on Windows), each of which connects
4000  * separately to the database. Inter-entry dependencies are respected,
4001  * and so is the RestorePass multi-pass structure. When we can no longer
4002  * make any entries ready to process, we exit. Normally, there will be
4003  * nothing left to do; but if there is, the third phase will mop up.
4004  */
4005 static void
4006 restore_toc_entries_parallel(ArchiveHandle *AH, ParallelState *pstate,
4007  TocEntry *pending_list)
4008 {
4009  binaryheap *ready_heap;
4010  TocEntry *next_work_item;
4011 
4012  pg_log_debug("entering restore_toc_entries_parallel");
4013 
4014  /* Set up ready_heap with enough room for all known TocEntrys */
4015  ready_heap = binaryheap_allocate(AH->tocCount,
4016  TocEntrySizeCompareBinaryheap,
4017  NULL);
4018 
4019  /*
4020  * The pending_list contains all items that we need to restore. Move all
4021  * items that are available to process immediately into the ready_heap.
4022  * After this setup, the pending list is everything that needs to be done
4023  * but is blocked by one or more dependencies, while the ready heap
4024  * contains items that have no remaining dependencies and are OK to
4025  * process in the current restore pass.
4026  */
4027  AH->restorePass = RESTORE_PASS_MAIN;
4028  move_to_ready_heap(pending_list, ready_heap, AH->restorePass);
4029 
4030  /*
4031  * main parent loop
4032  *
4033  * Keep going until there is no worker still running AND there is no work
4034  * left to be done. Note invariant: at top of loop, there should always
4035  * be at least one worker available to dispatch a job to.
4036  */
4037  pg_log_info("entering main parallel loop");
4038 
4039  for (;;)
4040  {
4041  /* Look for an item ready to be dispatched to a worker */
4042  next_work_item = pop_next_work_item(ready_heap, pstate);
4043  if (next_work_item != NULL)
4044  {
4045  /* If not to be restored, don't waste time launching a worker */
4046  if ((next_work_item->reqs & (REQ_SCHEMA | REQ_DATA)) == 0)
4047  {
4048  pg_log_info("skipping item %d %s %s",
4049  next_work_item->dumpId,
4050  next_work_item->desc, next_work_item->tag);
4051  /* Update its dependencies as though we'd completed it */
4052  reduce_dependencies(AH, next_work_item, ready_heap);
4053  /* Loop around to see if anything else can be dispatched */
4054  continue;
4055  }
4056 
4057  pg_log_info("launching item %d %s %s",
4058  next_work_item->dumpId,
4059  next_work_item->desc, next_work_item->tag);
4060 
4061  /* Dispatch to some worker */
4062  DispatchJobForTocEntry(AH, pstate, next_work_item, ACT_RESTORE,
4063  mark_restore_job_done, ready_heap);
4064  }
4065  else if (IsEveryWorkerIdle(pstate))
4066  {
4067  /*
4068  * Nothing is ready and no worker is running, so we're done with
4069  * the current pass or maybe with the whole process.
4070  */
4071  if (AH->restorePass == RESTORE_PASS_LAST)
4072  break; /* No more parallel processing is possible */
4073 
4074  /* Advance to next restore pass */
4075  AH->restorePass++;
4076  /* That probably allows some stuff to be made ready */
4077  move_to_ready_heap(pending_list, ready_heap, AH->restorePass);
4078  /* Loop around to see if anything's now ready */
4079  continue;
4080  }
4081  else
4082  {
4083  /*
4084  * We have nothing ready, but at least one child is working, so
4085  * wait for some subjob to finish.
4086  */
4087  }
4088 
4089  /*
4090  * Before dispatching another job, check to see if anything has
4091  * finished. We should check every time through the loop so as to
4092  * reduce dependencies as soon as possible. If we were unable to
4093  * dispatch any job this time through, wait until some worker finishes
4094  * (and, hopefully, unblocks some pending item). If we did dispatch
4095  * something, continue as soon as there's at least one idle worker.
4096  * Note that in either case, there's guaranteed to be at least one
4097  * idle worker when we return to the top of the loop. This ensures we
4098  * won't block inside DispatchJobForTocEntry, which would be
4099  * undesirable: we'd rather postpone dispatching until we see what's
4100  * been unblocked by finished jobs.
4101  */
4102  WaitForWorkers(AH, pstate,
4103  next_work_item ? WFW_ONE_IDLE : WFW_GOT_STATUS);
4104  }
4105 
4106  /* There should now be nothing in ready_heap. */
4107  Assert(binaryheap_empty(ready_heap));
4108 
4109  binaryheap_free(ready_heap);
4110 
4111  pg_log_info("finished main parallel loop");
4112 }
4113 
4114 /*
4115  * Main engine for parallel restore.
4116  *
4117  * Parallel restore is done in three phases. In this third phase,
4118  * we mop up any remaining TOC entries by processing them serially.
4119  * This phase normally should have nothing to do, but if we've somehow
4120  * gotten stuck due to circular dependencies or some such, this provides
4121  * at least some chance of completing the restore successfully.
4122  */
4123 static void
4124 restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list)
4125 {
4126  RestoreOptions *ropt = AH->public.ropt;
4127  TocEntry *te;
4128 
4129  pg_log_debug("entering restore_toc_entries_postfork");
4130 
4131  /*
4132  * Now reconnect the single parent connection.
4133  */
4134  ConnectDatabase((Archive *) AH, &ropt->cparams, true);
4135 
4136  /* re-establish fixed state */
4137  _doSetFixedOutputState(AH);
4138 
4139  /*
4140  * Make sure there is no work left due to, say, circular dependencies, or
4141  * some other pathological condition. If so, do it in the single parent
4142  * connection. We don't sweat about RestorePass ordering; it's likely we
4143  * already violated that.
4144  */
4145  for (te = pending_list->pending_next; te != pending_list; te = te->pending_next)
4146  {
4147  pg_log_info("processing missed item %d %s %s",
4148  te->dumpId, te->desc, te->tag);
4149  (void) restore_toc_entry(AH, te, false);
4150  }
4151 }
4152 
4153 /*
4154  * Check if te1 has an exclusive lock requirement for an item that te2 also
4155  * requires, whether or not te2's requirement is for an exclusive lock.
4156  */
4157 static bool
4158 has_lock_conflicts(TocEntry *te1, TocEntry *te2)
4159 {
4160  int j,
4161  k;
4162 
4163  for (j = 0; j < te1->nLockDeps; j++)
4164  {
4165  for (k = 0; k < te2->nDeps; k++)
4166  {
4167  if (te1->lockDeps[j] == te2->dependencies[k])
4168  return true;
4169  }
4170  }
4171  return false;
4172 }
4173 
4174 
4175 /*
4176  * Initialize the header of the pending-items list.
4177  *
4178  * This is a circular list with a dummy TocEntry as header, just like the
4179  * main TOC list; but we use separate list links so that an entry can be in
4180  * the main TOC list as well as in the pending list.
4181  */
4182 static void
4183 pending_list_header_init(TocEntry *l)
4184 {
4185  l->pending_prev = l->pending_next = l;
4186 }
4187 
4188 /* Append te to the end of the pending-list headed by l */
4189 static void
4190 pending_list_append(TocEntry *l, TocEntry *te)
4191 {
4192  te->pending_prev = l->pending_prev;
4193  l->pending_prev->pending_next = te;
4194  l->pending_prev = te;
4195  te->pending_next = l;
4196 }
4197 
4198 /* Remove te from the pending-list */
4199 static void
4200 pending_list_remove(TocEntry *te)
4201 {
4202  te->pending_prev->pending_next = te->pending_next;
4203  te->pending_next->pending_prev = te->pending_prev;
4204  te->pending_prev = NULL;
4205  te->pending_next = NULL;
4206 }
4207 
4208 
4209 /* qsort comparator for sorting TocEntries by dataLength */
4210 static int
4211 TocEntrySizeCompareQsort(const void *p1, const void *p2)
4212 {
4213  const TocEntry *te1 = *(const TocEntry *const *) p1;
4214  const TocEntry *te2 = *(const TocEntry *const *) p2;
4215 
4216  /* Sort by decreasing dataLength */
4217  if (te1->dataLength > te2->dataLength)
4218  return -1;
4219  if (te1->dataLength < te2->dataLength)
4220  return 1;
4221 
4222  /* For equal dataLengths, sort by dumpId, just to be stable */
4223  if (te1->dumpId < te2->dumpId)
4224  return -1;
4225  if (te1->dumpId > te2->dumpId)
4226  return 1;
4227 
4228  return 0;
4229 }
4230 
4231 /* binaryheap comparator for sorting TocEntries by dataLength */
4232 static int
4233 TocEntrySizeCompareBinaryheap(void *p1, void *p2, void *arg)
4234 {
4235  /* return opposite of qsort comparator for max-heap */
4236  return -TocEntrySizeCompareQsort(&p1, &p2);
4237 }
4238 
4239 
4240 /*
4241  * Move all immediately-ready items from pending_list to ready_heap.
4242  *
4243  * Items are considered ready if they have no remaining dependencies and
4244  * they belong in the current restore pass. (See also reduce_dependencies,
4245  * which applies the same logic one-at-a-time.)
4246  */
4247 static void
4248 move_to_ready_heap(TocEntry *pending_list,
4249  binaryheap *ready_heap,
4250  RestorePass pass)
4251 {
4252  TocEntry *te;
4253  TocEntry *next_te;
4254 
4255  for (te = pending_list->pending_next; te != pending_list; te = next_te)
4256  {
4257  /* must save list link before possibly removing te from list */
4258  next_te = te->pending_next;
4259 
4260  if (te->depCount == 0 &&
4261  _tocEntryRestorePass(te) == pass)
4262  {
4263  /* Remove it from pending_list ... */
4264  pending_list_remove(te);
4265  /* ... and add to ready_heap */
4266  binaryheap_add(ready_heap, te);
4267  }
4268  }
4269 }
4270 
4271 /*
4272  * Find the next work item (if any) that is capable of being run now,
4273  * and remove it from the ready_heap.
4274  *
4275  * Returns the item, or NULL if nothing is runnable.
4276  *
4277  * To qualify, the item must have no remaining dependencies
4278  * and no requirements for locks that are incompatible with
4279  * items currently running. Items in the ready_heap are known to have
4280  * no remaining dependencies, but we have to check for lock conflicts.
4281  */
4282 static TocEntry *
4283 pop_next_work_item(binaryheap *ready_heap,
4284  ParallelState *pstate)
4285 {
4286  /*
4287  * Search the ready_heap until we find a suitable item. Note that we do a
4288  * sequential scan through the heap nodes, so even though we will first
4289  * try to choose the highest-priority item, we might end up picking
4290  * something with a much lower priority. However, we expect that we will
4291  * typically be able to pick one of the first few items, which should
4292  * usually have a relatively high priority.
4293  */
4294  for (int i = 0; i < binaryheap_size(ready_heap); i++)
4295  {
4296  TocEntry *te = (TocEntry *) binaryheap_get_node(ready_heap, i);
4297  bool conflicts = false;
4298 
4299  /*
4300  * Check to see if the item would need exclusive lock on something
4301  * that a currently running item also needs lock on, or vice versa. If
4302  * so, we don't want to schedule them together.
4303  */
4304  for (int k = 0; k < pstate->numWorkers; k++)
4305  {
4306  TocEntry *running_te = pstate->te[k];
4307 
4308  if (running_te == NULL)
4309  continue;
4310  if (has_lock_conflicts(te, running_te) ||
4311  has_lock_conflicts(running_te, te))
4312  {
4313  conflicts = true;
4314  break;
4315  }
4316  }
4317 
4318  if (conflicts)
4319  continue;
4320 
4321  /* passed all tests, so this item can run */
4322  binaryheap_remove_node(ready_heap, i);
4323  return te;
4324  }
4325 
4326  pg_log_debug("no item ready");
4327  return NULL;
4328 }
4329 
4330 
4331 /*
4332  * Restore a single TOC item in parallel with others
4333  *
4334  * this is run in the worker, i.e. in a thread (Windows) or a separate process
4335  * (everything else). A worker process executes several such work items during
4336  * a parallel backup or restore. Once we terminate here and report back that
4337  * our work is finished, the leader process will assign us a new work item.
4338  */
4339 int
4340 parallel_restore(ArchiveHandle *AH, TocEntry *te)
4341 {
4342  int status;
4343 
4344  Assert(AH->connection != NULL);
4345 
4346  /* Count only errors associated with this TOC entry */
4347  AH->public.n_errors = 0;
4348 
4349  /* Restore the TOC item */
4350  status = restore_toc_entry(AH, te, true);
4351 
4352  return status;
4353 }
4354 
4355 
4356 /*
4357  * Callback function that's invoked in the leader process after a step has
4358  * been parallel restored.
4359  *
4360  * Update status and reduce the dependency count of any dependent items.
4361  */
4362 static void
4363 mark_restore_job_done(ArchiveHandle *AH,
4364  TocEntry *te,
4365  int status,
4366  void *callback_data)
4367 {
4368  binaryheap *ready_heap = (binaryheap *) callback_data;
4369 
4370  pg_log_info("finished item %d %s %s",
4371  te->dumpId, te->desc, te->tag);
4372 
4373  if (status == WORKER_CREATE_DONE)
4374  mark_create_done(AH, te);
4375  else if (status == WORKER_INHIBIT_DATA)
4376  {
4377  inhibit_data_for_failed_table(AH, te);
4378  AH->public.n_errors++;
4379  }
4380  else if (status == WORKER_IGNORED_ERRORS)
4381  AH->public.n_errors++;
4382  else if (status != 0)
4383  pg_fatal("worker process failed: exit code %d",
4384  status);
4385 
4386  reduce_dependencies(AH, te, ready_heap);
4387 }
4388 
4389 
4390 /*
4391  * Process the dependency information into a form useful for parallel restore.
4392  *
4393  * This function takes care of fixing up some missing or badly designed
4394  * dependencies, and then prepares subsidiary data structures that will be
4395  * used in the main parallel-restore logic, including:
4396  * 1. We build the revDeps[] arrays of incoming dependency dumpIds.
4397  * 2. We set up depCount fields that are the number of as-yet-unprocessed
4398  * dependencies for each TOC entry.
4399  *
4400  * We also identify locking dependencies so that we can avoid trying to
4401  * schedule conflicting items at the same time.
4402  */
4403 static void
4404 fix_dependencies(ArchiveHandle *AH)
4405 {
4406  TocEntry *te;
4407  int i;
4408 
4409  /*
4410  * Initialize the depCount/revDeps/nRevDeps fields, and make sure the TOC
4411  * items are marked as not being in any parallel-processing list.
4412  */
4413  for (te = AH->toc->next; te != AH->toc; te = te->next)
4414  {
4415  te->depCount = te->nDeps;
4416  te->revDeps = NULL;
4417  te->nRevDeps = 0;
4418  te->pending_prev = NULL;
4419  te->pending_next = NULL;
4420  }
4421 
4422  /*
4423  * POST_DATA items that are shown as depending on a table need to be
4424  * re-pointed to depend on that table's data, instead. This ensures they
4425  * won't get scheduled until the data has been loaded.
4426  */
4427  repoint_table_dependencies(AH);
4428 
4429  /*
4430  * Pre-8.4 versions of pg_dump neglected to set up a dependency from BLOB
4431  * COMMENTS to BLOBS. Cope. (We assume there's only one BLOBS and only
4432  * one BLOB COMMENTS in such files.)
4433  */
4434  if (AH->version < K_VERS_1_11)
4435  {
4436  for (te = AH->toc->next; te != AH->toc; te = te->next)
4437  {
4438  if (strcmp(te->desc, "BLOB COMMENTS") == 0 && te->nDeps == 0)
4439  {
4440  TocEntry *te2;
4441 
4442  for (te2 = AH->toc->next; te2 != AH->toc; te2 = te2->next)
4443  {
4444  if (strcmp(te2->desc, "BLOBS") == 0)
4445  {
4446  te->dependencies = (DumpId *) pg_malloc(sizeof(DumpId));
4447  te->dependencies[0] = te2->dumpId;
4448  te->nDeps++;
4449  te->depCount++;
4450  break;
4451  }
4452  }
4453  break;
4454  }
4455  }
4456  }
4457 
4458  /*
4459  * At this point we start to build the revDeps reverse-dependency arrays,
4460  * so all changes of dependencies must be complete.
4461  */
4462 
4463  /*
4464  * Count the incoming dependencies for each item. Also, it is possible
4465  * that the dependencies list items that are not in the archive at all
4466  * (that should not happen in 9.2 and later, but is highly likely in older
4467  * archives). Subtract such items from the depCounts.
4468  */
4469  for (te = AH->toc->next; te != AH->toc; te = te->next)
4470  {
4471  for (i = 0; i < te->nDeps; i++)
4472  {
4473  DumpId depid = te->dependencies[i];
4474 
4475  if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL)
4476  AH->tocsByDumpId[depid]->nRevDeps++;
4477  else
4478  te->depCount--;
4479  }
4480  }
4481 
4482  /*
4483  * Allocate space for revDeps[] arrays, and reset nRevDeps so we can use
4484  * it as a counter below.
4485  */
4486  for (te = AH->toc->next; te != AH->toc; te = te->next)
4487  {
4488  if (te->nRevDeps > 0)
4489  te->revDeps = (DumpId *) pg_malloc(te->nRevDeps * sizeof(DumpId));
4490  te->nRevDeps = 0;
4491  }
4492 
4493  /*
4494  * Build the revDeps[] arrays of incoming-dependency dumpIds. This had
4495  * better agree with the loops above.
4496  */
4497  for (te = AH->toc->next; te != AH->toc; te = te->next)
4498  {
4499  for (i = 0; i < te->nDeps; i++)
4500  {
4501  DumpId depid = te->dependencies[i];
4502 
4503  if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL)
4504  {
4505  TocEntry *otherte = AH->tocsByDumpId[depid];
4506 
4507  otherte->revDeps[otherte->nRevDeps++] = te->dumpId;
4508  }
4509  }
4510  }
4511 
4512  /*
4513  * Lastly, work out the locking dependencies.
4514  */
4515  for (te = AH->toc->next; te != AH->toc; te = te->next)
4516  {
4517  te->lockDeps = NULL;
4518  te->nLockDeps = 0;
4519  identify_locking_dependencies(AH, te);
4520  }
4521 }
4522 
4523 /*
4524  * Change dependencies on table items to depend on table data items instead,
4525  * but only in POST_DATA items.
4526  *
4527  * Also, for any item having such dependency(s), set its dataLength to the
4528  * largest dataLength of the table data items it depends on. This ensures
4529  * that parallel restore will prioritize larger jobs (index builds, FK
4530  * constraint checks, etc) over smaller ones, avoiding situations where we
4531  * end a restore with only one active job working on a large table.
4532  */
4533 static void
4534 repoint_table_dependencies(ArchiveHandle *AH)
4535 {
4536  TocEntry *te;
4537  int i;
4538  DumpId olddep;
4539 
4540  for (te = AH->toc->next; te != AH->toc; te = te->next)
4541  {
4542  if (te->section != SECTION_POST_DATA)
4543  continue;
4544  for (i = 0; i < te->nDeps; i++)
4545  {
4546  olddep = te->dependencies[i];
4547  if (olddep <= AH->maxDumpId &&
4548  AH->tableDataId[olddep] != 0)
4549  {
4550  DumpId tabledataid = AH->tableDataId[olddep];
4551  TocEntry *tabledatate = AH->tocsByDumpId[tabledataid];
4552 
4553  te->dependencies[i] = tabledataid;
4554  te->dataLength = Max(te->dataLength, tabledatate->dataLength);
4555  pg_log_debug("transferring dependency %d -> %d to %d",
4556  te->dumpId, olddep, tabledataid);
4557  }
4558  }
4559  }
4560 }
4561 
4562 /*
4563  * Identify which objects we'll need exclusive lock on in order to restore
4564  * the given TOC entry (*other* than the one identified by the TOC entry
4565  * itself). Record their dump IDs in the entry's lockDeps[] array.
4566  */
4567 static void
4568 identify_locking_dependencies(ArchiveHandle *AH, TocEntry *te)
4569 {
4570  DumpId *lockids;
4571  int nlockids;
4572  int i;
4573 
4574  /*
4575  * We only care about this for POST_DATA items. PRE_DATA items are not
4576  * run in parallel, and DATA items are all independent by assumption.
4577  */
4578  if (te->section != SECTION_POST_DATA)
4579  return;
4580 
4581  /* Quick exit if no dependencies at all */
4582  if (te->nDeps == 0)
4583  return;
4584 
4585  /*
4586  * Most POST_DATA items are ALTER TABLEs or some moral equivalent of that,
4587  * and hence require exclusive lock. However, we know that CREATE INDEX
4588  * does not. (Maybe someday index-creating CONSTRAINTs will fall in that
4589  * category too ... but today is not that day.)
4590  */
4591  if (strcmp(te->desc, "INDEX") == 0)
4592  return;
4593 
4594  /*
4595  * We assume the entry requires exclusive lock on each TABLE or TABLE DATA
4596  * item listed among its dependencies. Originally all of these would have
4597  * been TABLE items, but repoint_table_dependencies would have repointed
4598  * them to the TABLE DATA items if those are present (which they might not
4599  * be, eg in a schema-only dump). Note that all of the entries we are
4600  * processing here are POST_DATA; otherwise there might be a significant
4601  * difference between a dependency on a table and a dependency on its
4602  * data, so that closer analysis would be needed here.
4603  */
4604  lockids = (DumpId *) pg_malloc(te->nDeps * sizeof(DumpId));
4605  nlockids = 0;
4606  for (i = 0; i < te->nDeps; i++)
4607  {
4608  DumpId depid = te->dependencies[i];
4609 
4610  if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL &&
4611  ((strcmp(AH->tocsByDumpId[depid]->desc, "TABLE DATA") == 0) ||
4612  strcmp(AH->tocsByDumpId[depid]->desc, "TABLE") == 0))
4613  lockids[nlockids++] = depid;
4614  }
4615 
4616  if (nlockids == 0)
4617  {
4618  free(lockids);
4619  return;
4620  }
4621 
4622  te->lockDeps = pg_realloc(lockids, nlockids * sizeof(DumpId));
4623  te->nLockDeps = nlockids;
4624 }
4625 
4626 /*
4627  * Remove the specified TOC entry from the depCounts of items that depend on
4628  * it, thereby possibly making them ready-to-run. Any pending item that
4629  * becomes ready should be moved to the ready_heap, if that's provided.
4630  */
4631 static void
4632 reduce_dependencies(ArchiveHandle *AH, TocEntry *te,
4633  binaryheap *ready_heap)
4634 {
4635  int i;
4636 
4637  pg_log_debug("reducing dependencies for %d", te->dumpId);
4638 
4639  for (i = 0; i < te->nRevDeps; i++)
4640  {
4641  TocEntry *otherte = AH->tocsByDumpId[te->revDeps[i]];
4642 
4643  Assert(otherte->depCount > 0);
4644  otherte->depCount--;
4645 
4646  /*
4647  * It's ready if it has no remaining dependencies, and it belongs in
4648  * the current restore pass, and it is currently a member of the
4649  * pending list (that check is needed to prevent double restore in
4650  * some cases where a list-file forces out-of-order restoring).
4651  * However, if ready_heap == NULL then caller doesn't want any list
4652  * memberships changed.
4653  */
4654  if (otherte->depCount == 0 &&
4655  _tocEntryRestorePass(otherte) == AH->restorePass &&
4656  otherte->pending_prev != NULL &&
4657  ready_heap != NULL)
4658  {
4659  /* Remove it from pending list ... */
4660  pending_list_remove(otherte);
4661  /* ... and add to ready_heap */
4662  binaryheap_add(ready_heap, otherte);
4663  }
4664  }
4665 }
4666 
4667 /*
4668  * Set the created flag on the DATA member corresponding to the given
4669  * TABLE member
4670  */
4671 static void
4672 mark_create_done(ArchiveHandle *AH, TocEntry *te)
4673 {
4674  if (AH->tableDataId[te->dumpId] != 0)
4675  {
4676  TocEntry *ted = AH->tocsByDumpId[AH->tableDataId[te->dumpId]];
4677 
4678  ted->created = true;
4679  }
4680 }
4681 
4682 /*
4683  * Mark the DATA member corresponding to the given TABLE member
4684  * as not wanted
4685  */
4686 static void
4687 inhibit_data_for_failed_table(ArchiveHandle *AH, TocEntry *te)
4688 {
4689  pg_log_info("table \"%s\" could not be created, will not restore its data",
4690  te->tag);
4691 
4692  if (AH->tableDataId[te->dumpId] != 0)
4693  {
4694  TocEntry *ted = AH->tocsByDumpId[AH->tableDataId[te->dumpId]];
4695 
4696  ted->reqs = 0;
4697  }
4698 }
4699 
4700 /*
4701  * Clone and de-clone routines used in parallel restoration.
4702  *
4703  * Enough of the structure is cloned to ensure that there is no
4704  * conflict between different threads each with their own clone.
4705  */
4706 ArchiveHandle *
4707 CloneArchive(ArchiveHandle *AH)
4708 {
4709  ArchiveHandle *clone;
4710 
4711  /* Make a "flat" copy */
4712  clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
4713  memcpy(clone, AH, sizeof(ArchiveHandle));
4714 
4715  /* Handle format-independent fields */
4716  memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
4717 
4718  /* The clone will have its own connection, so disregard connection state */
4719  clone->connection = NULL;
4720  clone->connCancel = NULL;
4721  clone->currUser = NULL;
4722  clone->currSchema = NULL;
4723  clone->currTableAm = NULL;
4724  clone->currTablespace = NULL;
4725 
4726  /* savedPassword must be local in case we change it while connecting */
4727  if (clone->savedPassword)
4728  clone->savedPassword = pg_strdup(clone->savedPassword);
4729 
4730  /* clone has its own error count, too */
4731  clone->public.n_errors = 0;
4732 
4733  /*
4734  * Connect our new clone object to the database, using the same connection
4735  * parameters used for the original connection.
4736  */
4737  ConnectDatabase((Archive *) clone, &clone->public.ropt->cparams, true);
4738 
4739  /* re-establish fixed state */
4740  if (AH->mode == archModeRead)
4741  _doSetFixedOutputState(clone);
4742  /* in write case, setupDumpWorker will fix up connection state */
4743 
4744  /* Let the format-specific code have a chance too */
4745  clone->ClonePtr(clone);
4746 
4747  Assert(clone->connection != NULL);
4748  return clone;
4749 }
4750 
4751 /*
4752  * Release clone-local storage.
4753  *
4754  * Note: we assume any clone-local connection was already closed.
4755  */
4756 void
4757 DeCloneArchive(ArchiveHandle *AH)
4758 {
4759  /* Should not have an open database connection */
4760  Assert(AH->connection == NULL);
4761 
4762  /* Clear format-specific state */
4763  AH->DeClonePtr(AH);
4764 
4765  /* Clear state allocated by CloneArchive */
4766  if (AH->sqlparse.curCmd)
4767  destroyPQExpBuffer(AH->sqlparse.curCmd);
4768 
4769  /* Clear any connection-local state */
4770  free(AH->currUser);
4771  free(AH->currSchema);
4772  free(AH->currTablespace);
4773  free(AH->currTableAm);
4774  free(AH->savedPassword);
4775 
4776  free(AH);
4777 }
lo_write
int lo_write(int fd, const char *buf, int len)
Definition: be-fsstubs.c:182
ParallelBackupEnd
void ParallelBackupEnd(ArchiveHandle *AH, ParallelState *pstate)
Definition: parallel.c:1059
WaitForWorkers
void WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
Definition: parallel.c:1451
DispatchJobForTocEntry
void DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te, T_Action act, ParallelCompletionPtr callback, void *callback_data)
Definition: parallel.c:1205
IsEveryWorkerIdle
bool IsEveryWorkerIdle(ParallelState *pstate)
Definition: parallel.c:1268
ParallelBackupStart
ParallelState * ParallelBackupStart(ArchiveHandle *AH)
Definition: parallel.c:897
WFW_ALL_IDLE
@ WFW_ALL_IDLE
Definition: parallel.h:35
WFW_GOT_STATUS
@ WFW_GOT_STATUS
Definition: parallel.h:33
WFW_ONE_IDLE
@ WFW_ONE_IDLE
Definition: parallel.h:34
binaryheap_remove_node
void binaryheap_remove_node(binaryheap *heap, int n)
Definition: binaryheap.c:225
binaryheap_add
void binaryheap_add(binaryheap *heap, bh_node_type d)
Definition: binaryheap.c:154
binaryheap_allocate
binaryheap * binaryheap_allocate(int capacity, binaryheap_comparator compare, void *arg)
Definition: binaryheap.c:39
binaryheap_free
void binaryheap_free(binaryheap *heap)
Definition: binaryheap.c:75
binaryheap_size
#define binaryheap_size(h)
Definition: binaryheap.h:66
binaryheap_empty
#define binaryheap_empty(h)
Definition: binaryheap.h:65
binaryheap_get_node
#define binaryheap_get_node(h, n)
Definition: binaryheap.h:67
PG_BINARY_R
#define PG_BINARY_R
Definition: c.h:1285
ngettext
#define ngettext(s, p, n)
Definition: c.h:1194
PG_BINARY_A
#define PG_BINARY_A
Definition: c.h:1284
Max
#define Max(x, y)
Definition: c.h:987
PG_BINARY_W
#define PG_BINARY_W
Definition: c.h:1286
EndCompressFileHandle
bool EndCompressFileHandle(CompressFileHandle *CFH)
Definition: compress_io.c:289
supports_compression
char * supports_compression(const pg_compress_specification compression_spec)
Definition: compress_io.c:88
InitCompressFileHandle
CompressFileHandle * InitCompressFileHandle(const pg_compress_specification compression_spec)
Definition: compress_io.c:195
compress_io.h
get_compress_algorithm_name
const char * get_compress_algorithm_name(pg_compress_algorithm algorithm)
Definition: compression.c:69
PG_COMPRESSION_GZIP
@ PG_COMPRESSION_GZIP
Definition: compression.h:24
PG_COMPRESSION_NONE
@ PG_COMPRESSION_NONE
Definition: compression.h:23
PGDUMP_STRFTIME_FMT
#define PGDUMP_STRFTIME_FMT
Definition: dumputils.h:33
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1069
pg_char_to_encoding
int pg_char_to_encoding(const char *name)
Definition: encnames.c:550
pg_encoding_to_char
const char * pg_encoding_to_char(int encoding)
Definition: encnames.c:588
PQdb
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:7094
PQerrorMessage
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:7248
PQresultStatus
ExecStatusType PQresultStatus(const PGresult *res)
Definition: fe-exec.c:3325
PQexec
PGresult * PQexec(PGconn *conn, const char *query)
Definition: fe-exec.c:2228
lo_close
int lo_close(PGconn *conn, int fd)
Definition: fe-lobj.c:96
lo_open
int lo_open(PGconn *conn, Oid lobjId, int mode)
Definition: fe-lobj.c:57
lo_create
Oid lo_create(PGconn *conn, Oid lobjId)
Definition: fe-lobj.c:474
pg_realloc
void * pg_realloc(void *ptr, size_t size)
Definition: fe_memutils.c:65
pg_malloc0
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
pg_strdup
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
pg_free
void pg_free(void *ptr)
Definition: fe_memutils.c:105
pg_malloc
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
DataDirSyncMethod
DataDirSyncMethod
Definition: file_utils.h:28
DATA_DIR_SYNC_METHOD_FSYNC
@ DATA_DIR_SYNC_METHOD_FSYNC
Definition: file_utils.h:29
free
#define free(a)
Definition: header.h:65
remaining
int remaining
Definition: informix.c:667
sign
char sign
Definition: informix.c:668
b
int b
Definition: isn.c:70
true
return true
Definition: isn.c:126
j
int j
Definition: isn.c:74
i
int i
Definition: isn.c:73
if
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
PGRES_COMMAND_OK
@ PGRES_COMMAND_OK
Definition: libpq-fe.h:97
INV_WRITE
#define INV_WRITE
Definition: libpq-fs.h:21
fmt
static void const char * fmt
Definition: libpq_pipeline.c:29
va_end
va_end(args)
Assert
Assert(fmt[strlen(fmt) - 1] !='\n')
va_start
va_start(args, fmt)
tm
static struct pg_tm tm
Definition: localtime.c:104
pg_log_generic_v
void pg_log_generic_v(enum pg_log_level level, enum pg_log_part part, const char *pg_restrict fmt, va_list ap)
Definition: logging.c:216
pg_log_info
#define pg_log_info(...)
Definition: logging.h:124
PG_LOG_PRIMARY
@ PG_LOG_PRIMARY
Definition: logging.h:67
PG_LOG_ERROR
@ PG_LOG_ERROR
Definition: logging.h:43
pg_log_debug
#define pg_log_debug(...)
Definition: logging.h:133
generate_unaccent_rules.str
str
Definition: generate_unaccent_rules.py:280
generate_unaccent_rules.stdout
stdout
Definition: generate_unaccent_rules.py:35
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:283
opts
static AmcheckOptions opts
Definition: pg_amcheck.c:110
ConnectDatabase
void ConnectDatabase(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition: pg_backup_db.c:110
SECTION_NONE
@ SECTION_NONE
Definition: pg_backup.h:57
SECTION_POST_DATA
@ SECTION_POST_DATA
Definition: pg_backup.h:60
SECTION_PRE_DATA
@ SECTION_PRE_DATA
Definition: pg_backup.h:58
SECTION_DATA
@ SECTION_DATA
Definition: pg_backup.h:59
DumpId
int DumpId
Definition: pg_backup.h:268
SetupWorkerPtrType
void(* SetupWorkerPtrType)(Archive *AH)
Definition: pg_backup.h:278
ArchiveFormat
enum _archiveFormat ArchiveFormat
archModeWrite
@ archModeWrite
Definition: pg_backup.h:51
archModeAppend
@ archModeAppend
Definition: pg_backup.h:50
archModeRead
@ archModeRead
Definition: pg_backup.h:52
DisconnectDatabase
void DisconnectDatabase(Archive *AHX)
Definition: pg_backup_db.c:225
teSection
enum _teSection teSection
archUnknown
@ archUnknown
Definition: pg_backup.h:41
archTar
@ archTar
Definition: pg_backup.h:43
archCustom
@ archCustom
Definition: pg_backup.h:42
archDirectory
@ archDirectory
Definition: pg_backup.h:45
archNull
@ archNull
Definition: pg_backup.h:44
fix_dependencies
static void fix_dependencies(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:4404
repoint_table_dependencies
static void repoint_table_dependencies(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:4534
DeCloneArchive
void DeCloneArchive(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:4757
_discoverArchiveFormat
static int _discoverArchiveFormat(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:2081
TEXT_DUMPALL_HEADER
#define TEXT_DUMPALL_HEADER
Definition: pg_backup_archiver.c:46
TocIDRequired
int TocIDRequired(ArchiveHandle *AH, DumpId id)
Definition: pg_backup_archiver.c:1880
checkSeek
bool checkSeek(FILE *fp)
Definition: pg_backup_archiver.c:3848
ahwrite
void ahwrite(const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1687
warn_or_exit_horribly
void warn_or_exit_horribly(ArchiveHandle *AH, const char *fmt,...)
Definition: pg_backup_archiver.c:1734
WriteDataChunksForTocEntry
void WriteDataChunksForTocEntry(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:2416
_becomeOwner
static void _becomeOwner(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:3250
WriteHead
void WriteHead(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:3688
EndLO
int EndLO(Archive *AHX, Oid oid)
Definition: pg_backup_archiver.c:1278
SaveOutput
static CompressFileHandle * SaveOutput(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1575
_becomeUser
static void _becomeUser(ArchiveHandle *AH, const char *user)
Definition: pg_backup_archiver.c:3227
getTocEntryByDumpId
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)
Definition: pg_backup_archiver.c:1867
pending_list_append
static void pending_list_append(TocEntry *l, TocEntry *te)
Definition: pg_backup_archiver.c:4190
WriteInt
size_t WriteInt(ArchiveHandle *AH, int i)
Definition: pg_backup_archiver.c:1972
ProcessArchiveRestoreOptions
void ProcessArchiveRestoreOptions(Archive *AHX)
Definition: pg_backup_archiver.c:276
restore_toc_entry
static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel)
Definition: pg_backup_archiver.c:747
_moveBefore
static void _moveBefore(TocEntry *pos, TocEntry *te)
Definition: pg_backup_archiver.c:1801
_tocEntryIsACL
static bool _tocEntryIsACL(TocEntry *te)
Definition: pg_backup_archiver.c:3075
move_to_ready_heap
static void move_to_ready_heap(TocEntry *pending_list, binaryheap *ready_heap, RestorePass pass)
Definition: pg_backup_archiver.c:4248
_getObjectDescription
static void _getObjectDescription(PQExpBuffer buf, const TocEntry *te)
Definition: pg_backup_archiver.c:3430
buildTocEntryArrays
static void buildTocEntryArrays(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1826
identify_locking_dependencies
static void identify_locking_dependencies(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:4568
processEncodingEntry
static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:2677
processSearchPathEntry
static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:2721
archprintf
int archprintf(Archive *AH, const char *fmt,...)
Definition: pg_backup_archiver.c:1496
StrictNamesCheck
static void StrictNamesCheck(RestoreOptions *ropt)
Definition: pg_backup_archiver.c:2731
mark_restore_job_done
static void mark_restore_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
Definition: pg_backup_archiver.c:4363
CloneArchive
ArchiveHandle * CloneArchive(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:4707
WriteOffset
size_t WriteOffset(ArchiveHandle *AH, pgoff_t o, int wasSet)
Definition: pg_backup_archiver.c:1891
NewRestoreOptions
RestoreOptions * NewRestoreOptions(void)
Definition: pg_backup_archiver.c:965
_tocEntryRestorePass
static RestorePass _tocEntryRestorePass(TocEntry *te)
Definition: pg_backup_archiver.c:3042
StartLO
int StartLO(Archive *AHX, Oid oid)
Definition: pg_backup_archiver.c:1264
setupRestoreWorker
static void setupRestoreWorker(Archive *AHX)
Definition: pg_backup_archiver.c:207
CreateArchive
Archive * CreateArchive(const char *FileSpec, const ArchiveFormat fmt, const pg_compress_specification compression_spec, bool dosync, ArchiveMode mode, SetupWorkerPtrType setupDumpWorker, DataDirSyncMethod sync_method)
Definition: pg_backup_archiver.c:218
_reconnectToDB
static void _reconnectToDB(ArchiveHandle *AH, const char *dbname)
Definition: pg_backup_archiver.c:3186
TocEntrySizeCompareQsort
static int TocEntrySizeCompareQsort(const void *p1, const void *p2)
Definition: pg_backup_archiver.c:4211
StartRestoreLOs
void StartRestoreLOs(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1296
CloseArchive
void CloseArchive(Archive *AHX)
Definition: pg_backup_archiver.c:249
pending_list_header_init
static void pending_list_header_init(TocEntry *l)
Definition: pg_backup_archiver.c:4183
restore_toc_entries_parallel
static void restore_toc_entries_parallel(ArchiveHandle *AH, ParallelState *pstate, TocEntry *pending_list)
Definition: pg_backup_archiver.c:4006
SetOutput
static void SetOutput(ArchiveHandle *AH, const char *filename, const pg_compress_specification compression_spec)
Definition: pg_backup_archiver.c:1535
mark_create_done
static void mark_create_done(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:4672
TEXT_DUMP_HEADER
#define TEXT_DUMP_HEADER
Definition: pg_backup_archiver.c:45
_selectTableAccessMethod
static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
Definition: pg_backup_archiver.c:3377
WriteDataChunks
void WriteDataChunks(ArchiveHandle *AH, ParallelState *pstate)
Definition: pg_backup_archiver.c:2335
dumpTimestamp
static void dumpTimestamp(ArchiveHandle *AH, const char *msg, time_t tim)
Definition: pg_backup_archiver.c:3873
ahprintf
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
Definition: pg_backup_archiver.c:1596
_selectOutputSchema
static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName)
Definition: pg_backup_archiver.c:3266
mark_dump_job_done
static void mark_dump_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
Definition: pg_backup_archiver.c:2401
is_load_via_partition_root
static bool is_load_via_partition_root(TocEntry *te)
Definition: pg_backup_archiver.c:1045
_enableTriggersIfNecessary
static void _enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:1008
SortTocFromFile
void SortTocFromFile(Archive *AHX)
Definition: pg_backup_archiver.c:1408
ReadOffset
int ReadOffset(ArchiveHandle *AH, pgoff_t *o)
Definition: pg_backup_archiver.c:1908
ReadStr
char * ReadStr(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:2049
_printTocEntry
static void _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
Definition: pg_backup_archiver.c:3524
inhibit_data_for_failed_table
static void inhibit_data_for_failed_table(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:4687
ReadInt
int ReadInt(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:2003
restore_toc_entries_prefork
static void restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
Definition: pg_backup_archiver.c:3891
restore_toc_entries_postfork
static void restore_toc_entries_postfork(ArchiveHandle *AH, TocEntry *pending_list)
Definition: pg_backup_archiver.c:4124
RestoreOutput
static void RestoreOutput(ArchiveHandle *AH, CompressFileHandle *savedOutput)
Definition: pg_backup_archiver.c:1581
ArchiveEntry
TocEntry * ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts *opts)
Definition: pg_backup_archiver.c:1097
_doSetFixedOutputState
static void _doSetFixedOutputState(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:3090
PrintTOCSummary
void PrintTOCSummary(Archive *AHX)
Definition: pg_backup_archiver.c:1155
processStdStringsEntry
static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:2705
TocEntrySizeCompareBinaryheap
static int TocEntrySizeCompareBinaryheap(void *p1, void *p2, void *arg)
Definition: pg_backup_archiver.c:4233
RestoringToDB
static int RestoringToDB(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1633
ReadHead
void ReadHead(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:3714
SetArchiveOptions
void SetArchiveOptions(Archive *AH, DumpOptions *dopt, RestoreOptions *ropt)
Definition: pg_backup_archiver.c:263
pending_list_remove
static void pending_list_remove(TocEntry *te)
Definition: pg_backup_archiver.c:4200
has_lock_conflicts
static bool has_lock_conflicts(TocEntry *te1, TocEntry *te2)
Definition: pg_backup_archiver.c:4158
NewDumpOptions
DumpOptions * NewDumpOptions(void)
Definition: pg_backup_archiver.c:128
ReadToc
void ReadToc(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:2508
reduce_dependencies
static void reduce_dependencies(ArchiveHandle *AH, TocEntry *te, binaryheap *ready_heap)
Definition: pg_backup_archiver.c:4632
sanitize_line
static char * sanitize_line(const char *str, bool want_hyphen)
Definition: pg_backup_archiver.c:3665
EndRestoreLO
void EndRestoreLO(ArchiveHandle *AH, Oid oid)
Definition: pg_backup_archiver.c:1382
_selectTablespace
static void _selectTablespace(ArchiveHandle *AH, const char *tablespace)
Definition: pg_backup_archiver.c:3317
RestoreArchive
void RestoreArchive(Archive *AHX)
Definition: pg_backup_archiver.c:331
WriteToc
void WriteToc(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:2449
archputs
void archputs(const char *s, Archive *AH)
Definition: pg_backup_archiver.c:1489
_fileExistsInDirectory
static bool _fileExistsInDirectory(const char *dir, const char *filename)
Definition: pg_backup_archiver.c:2069
_tocEntryRequired
static int _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH)
Definition: pg_backup_archiver.c:2781
_doSetSessionAuth
static void _doSetSessionAuth(ArchiveHandle *AH, const char *user)
Definition: pg_backup_archiver.c:3143
EndRestoreLOs
void EndRestoreLOs(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1315
StartRestoreLO
void StartRestoreLO(ArchiveHandle *AH, Oid oid, bool drop)
Definition: pg_backup_archiver.c:1338
OpenArchive
Archive * OpenArchive(const char *FileSpec, const ArchiveFormat fmt)
Definition: pg_backup_archiver.c:234
InitDumpOptions
void InitDumpOptions(DumpOptions *opts)
Definition: pg_backup_archiver.c:140
_allocAH
static ArchiveHandle * _allocAH(const char *FileSpec, const ArchiveFormat fmt, const pg_compress_specification compression_spec, bool dosync, ArchiveMode mode, SetupWorkerPtrType setupWorkerPtr, DataDirSyncMethod sync_method)
Definition: pg_backup_archiver.c:2215
dumpOptionsFromRestoreOptions
DumpOptions * dumpOptionsFromRestoreOptions(RestoreOptions *ropt)
Definition: pg_backup_archiver.c:154
dump_lo_buf
static void dump_lo_buf(ArchiveHandle *AH)
Definition: pg_backup_archiver.c:1644
pop_next_work_item
static TocEntry * pop_next_work_item(binaryheap *ready_heap, ParallelState *pstate)
Definition: pg_backup_archiver.c:4283
WriteData
void WriteData(Archive *AHX, const void *data, size_t dLen)
Definition: pg_backup_archiver.c:1076
parallel_restore
int parallel_restore(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:4340
WriteStr
size_t WriteStr(ArchiveHandle *AH, const char *c)
Definition: pg_backup_archiver.c:2030
_disableTriggersIfNecessary
static void _disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.c:982
pg_backup_archiver.h
K_VERS_1_15
#define K_VERS_1_15
Definition: pg_backup_archiver.h:61
InitArchiveFmt_Null
void InitArchiveFmt_Null(ArchiveHandle *AH)
Definition: pg_backup_null.c:48
WORKER_CREATE_DONE
#define WORKER_CREATE_DONE
Definition: pg_backup_archiver.h:83
K_VERS_1_14
#define K_VERS_1_14
Definition: pg_backup_archiver.h:60
appendByteaLiteralAHX
#define appendByteaLiteralAHX(buf, str, len, AH)
Definition: pg_backup_archiver.h:414
ArchiveOpts
void struct _archiveOpts ArchiveOpts
EndDataPtrType
void(* EndDataPtrType)(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.h:116
K_VERS_SELF
#define K_VERS_SELF
Definition: pg_backup_archiver.h:67
K_VERS_1_10
#define K_VERS_1_10
Definition: pg_backup_archiver.h:56
StartDataPtrType
void(* StartDataPtrType)(ArchiveHandle *AH, TocEntry *te)
Definition: pg_backup_archiver.h:114
ARCHIVE_MAJOR
#define ARCHIVE_MAJOR(version)
Definition: pg_backup_archiver.h:42
ARCHIVE_MINOR
#define ARCHIVE_MINOR(version)
Definition: pg_backup_archiver.h:43
K_VERS_1_2
#define K_VERS_1_2
Definition: pg_backup_archiver.h:48
RESTORE_PASS_LAST
#define RESTORE_PASS_LAST
Definition: pg_backup_archiver.h:195
InitArchiveFmt_Custom
void InitArchiveFmt_Custom(ArchiveHandle *AH)
Definition: pg_backup_custom.c:106
K_OFFSET_NO_DATA
#define K_OFFSET_NO_DATA
Definition: pg_backup_archiver.h:76
InitArchiveFmt_Tar
void InitArchiveFmt_Tar(ArchiveHandle *AH)
Definition: pg_backup_tar.c:121
REQ_SCHEMA
#define REQ_SCHEMA
Definition: pg_backup_archiver.h:198
K_VERS_1_4
#define K_VERS_1_4
Definition: pg_backup_archiver.h:50
appendStringLiteralAHX
#define appendStringLiteralAHX(buf, str, AH)
Definition: pg_backup_archiver.h:411
DropLOIfExists
void DropLOIfExists(ArchiveHandle *AH, Oid oid)
Definition: pg_backup_db.c:545
MAKE_ARCHIVE_VERSION
#define MAKE_ARCHIVE_VERSION(major, minor, rev)
Definition: pg_backup_archiver.h:40
K_VERS_1_5
#define K_VERS_1_5
Definition: pg_backup_archiver.h:51
ReconnectToServer
void ReconnectToServer(ArchiveHandle *AH, const char *dbname)
Definition: pg_backup_db.c:74
ARCHIVE_REV
#define ARCHIVE_REV(version)
Definition: pg_backup_archiver.h:44
WRITE_ERROR_EXIT
#define WRITE_ERROR_EXIT
Definition: pg_backup_archiver.h:99
isValidTarHeader
bool isValidTarHeader(char *header)
Definition: pg_backup_tar.c:973
WORKER_IGNORED_ERRORS
#define WORKER_IGNORED_ERRORS
Definition: pg_backup_archiver.h:85
REQ_SPECIAL
#define REQ_SPECIAL
Definition: pg_backup_archiver.h:200
K_VERS_1_6
#define K_VERS_1_6
Definition: pg_backup_archiver.h:52
STAGE_INITIALIZING
@ STAGE_INITIALIZING
Definition: pg_backup_archiver.h:158
STAGE_PROCESSING
@ STAGE_PROCESSING
Definition: pg_backup_archiver.h:159
STAGE_NONE
@ STAGE_NONE
Definition: pg_backup_archiver.h:157
STAGE_FINALIZING
@ STAGE_FINALIZING
Definition: pg_backup_archiver.h:160
ACT_RESTORE
@ ACT_RESTORE
Definition: pg_backup_archiver.h:107
ACT_DUMP
@ ACT_DUMP
Definition: pg_backup_archiver.h:106
K_VERS_1_0
#define K_VERS_1_0
Definition: pg_backup_archiver.h:47
K_OFFSET_POS_NOT_SET
#define K_OFFSET_POS_NOT_SET
Definition: pg_backup_archiver.h:74
K_OFFSET_POS_SET
#define K_OFFSET_POS_SET
Definition: pg_backup_archiver.h:75
K_VERS_MAX
#define K_VERS_MAX
Definition: pg_backup_archiver.h:70
K_VERS_1_8
#define K_VERS_1_8
Definition: pg_backup_archiver.h:54
WORKER_OK
#define WORKER_OK
Definition: pg_backup_archiver.h:82
OUTPUT_COPYDATA
@ OUTPUT_COPYDATA
Definition: pg_backup_archiver.h:166
OUTPUT_SQLCMDS
@ OUTPUT_SQLCMDS
Definition: pg_backup_archiver.h:165
OUTPUT_OTHERDATA
@ OUTPUT_OTHERDATA
Definition: pg_backup_archiver.h:167
K_VERS_1_12
#define K_VERS_1_12
Definition: pg_backup_archiver.h:58
REQ_DATA
#define REQ_DATA
Definition: pg_backup_archiver.h:199
READ_ERROR_EXIT
#define READ_ERROR_EXIT(fd)
Definition: pg_backup_archiver.h:91
InitArchiveFmt_Directory
void InitArchiveFmt_Directory(ArchiveHandle *AH)
Definition: pg_backup_directory.c:107
K_VERS_1_11
#define K_VERS_1_11
Definition: pg_backup_archiver.h:57
K_VERS_1_9
#define K_VERS_1_9
Definition: pg_backup_archiver.h:55
WORKER_INHIBIT_DATA
#define WORKER_INHIBIT_DATA
Definition: pg_backup_archiver.h:84
RestorePass
RestorePass
Definition: pg_backup_archiver.h:190
RESTORE_PASS_ACL
@ RESTORE_PASS_ACL
Definition: pg_backup_archiver.h:192
RESTORE_PASS_MAIN
@ RESTORE_PASS_MAIN
Definition: pg_backup_archiver.h:191
K_VERS_1_3
#define K_VERS_1_3
Definition: pg_backup_archiver.h:49
K_VERS_1_7
#define K_VERS_1_7
Definition: pg_backup_archiver.h:53
EndDBCopyMode
void EndDBCopyMode(Archive *AHX, const char *tocEntryTag)
Definition: pg_backup_db.c:500
ExecuteSqlCommandBuf
int ExecuteSqlCommandBuf(Archive *AHX, const char *buf, size_t bufLen)
Definition: pg_backup_db.c:445
pg_backup_db.h
arg
void * arg
Definition: pg_backup_utils.c:27
pg_backup_utils.h
DUMP_PRE_DATA
#define DUMP_PRE_DATA
Definition: pg_backup_utils.h:21
DUMP_DATA
#define DUMP_DATA
Definition: pg_backup_utils.h:22
DUMP_UNSECTIONED
#define DUMP_UNSECTIONED
Definition: pg_backup_utils.h:24
pg_fatal
#define pg_fatal(...)
Definition: pg_backup_utils.h:36
DUMP_POST_DATA
#define DUMP_POST_DATA
Definition: pg_backup_utils.h:23
mode
static PgChecksumMode mode
Definition: pg_checksums.c:56
MAXPGPATH
#define MAXPGPATH
Definition: pg_config_manual.h:115
len
const void size_t len
Definition: pg_crc32c_sse42.c:24
data
const void * data
Definition: pg_crc32c_sse42.c:23
sig
static int sig
Definition: pg_ctl.c:79
encoding
int32 encoding
Definition: pg_database.h:41
dosync
static bool dosync
Definition: pg_dump.c:102
setupDumpWorker
static void setupDumpWorker(Archive *AH)
Definition: pg_dump.c:1318
exit_nicely
#define exit_nicely(code)
Definition: pg_dumpall.c:124
filename
static char * filename
Definition: pg_dumpall.c:119
pg_get_line_buf
bool pg_get_line_buf(FILE *stream, StringInfo buf)
Definition: pg_get_line.c:95
user
static char * user
Definition: pg_regress.c:112
buf
static char * buf
Definition: pg_test_fsync.c:67
tablespace
char * tablespace
Definition: pgbench.c:216
pg_log_warning
#define pg_log_warning(...)
Definition: pgfnames.c:24
sprintf
#define sprintf
Definition: port.h:240
snprintf
#define snprintf
Definition: port.h:238
qsort
#define qsort(a, b, c, d)
Definition: port.h:445
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
Oid
unsigned int Oid
Definition: postgres_ext.h:31
postgres_fe.h
createPQExpBuffer
PQExpBuffer createPQExpBuffer(void)
Definition: pqexpbuffer.c:72
initPQExpBuffer
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:90
appendPQExpBuffer
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:265
destroyPQExpBuffer
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:114
appendPQExpBufferChar
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:378
appendPQExpBufferStr
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:367
termPQExpBuffer
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:129
c
char * c
Definition: preproc-cursor.c:31
pvsnprintf
size_t pvsnprintf(char *buf, size_t len, const char *fmt, va_list args)
Definition: psprintf.c:106
simple_string_list_member
bool simple_string_list_member(SimpleStringList *list, const char *val)
Definition: simple_list.c:87
simple_string_list_not_touched
const char * simple_string_list_not_touched(SimpleStringList *list)
Definition: simple_list.c:144
dbname
char * dbname
Definition: streamutil.c:51
appendPsqlMetaConnect
void appendPsqlMetaConnect(PQExpBuffer buf, const char *dbname)
Definition: string_utils.c:590
fmtId
const char * fmtId(const char *rawid)
Definition: string_utils.c:64
fmtQualifiedId
const char * fmtQualifiedId(const char *schema, const char *id)
Definition: string_utils.c:145
string_utils.h
initStringInfo
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
Archive::minRemoteVersion
int minRemoteVersion
Definition: pg_backup.h:220
Archive::remoteVersionStr
char * remoteVersionStr
Definition: pg_backup.h:216
Archive::dopt
DumpOptions * dopt
Definition: pg_backup.h:212
Archive::exit_on_error
bool exit_on_error
Definition: pg_backup.h:235
Archive::searchpath
char * searchpath
Definition: pg_backup.h:231
Archive::maxRemoteVersion
int maxRemoteVersion
Definition: pg_backup.h:221
Archive::n_errors
int n_errors
Definition: pg_backup.h:236
Archive::std_strings
bool std_strings
Definition: pg_backup.h:228
Archive::numWorkers
int numWorkers
Definition: pg_backup.h:223
Archive::encoding
int encoding
Definition: pg_backup.h:227
Archive::verbose
int verbose
Definition: pg_backup.h:215
Archive::ropt
RestoreOptions * ropt
Definition: pg_backup.h:213
CatalogId::tableoid
Oid tableoid
Definition: pg_backup.h:264
CompressFileHandle::write_func
bool(* write_func)(const void *ptr, size_t size, struct CompressFileHandle *CFH)
Definition: compress_io.h:139
CompressFileHandle::open_func
bool(* open_func)(const char *path, int fd, const char *mode, CompressFileHandle *CFH)
Definition: compress_io.h:111
ParallelState::te
TocEntry ** te
Definition: parallel.h:59
ParallelState::numWorkers
int numWorkers
Definition: parallel.h:57
SimpleStringList::head
SimpleStringListCell * head
Definition: simple_list.h:42
_archiveHandle
Definition: pg_backup_archiver.h:203
_archiveHandle::version
int version
Definition: pg_backup_archiver.h:205
_archiveHandle::stage
ArchiverStage stage
Definition: pg_backup_archiver.h:321
_archiveHandle::restorePass
RestorePass restorePass
Definition: pg_backup_archiver.h:323
_archiveHandle::format
ArchiveFormat format
Definition: pg_backup_archiver.h:215
_archiveHandle::lo_buf_size
size_t lo_buf_size
Definition: pg_backup_archiver.h:318
_archiveHandle::lookaheadPos
size_t lookaheadPos
Definition: pg_backup_archiver.h:236
_archiveHandle::intSize
size_t intSize
Definition: pg_backup_archiver.h:212
_archiveHandle::toc
struct _tocEntry * toc
Definition: pg_backup_archiver.h:294
_archiveHandle::savedPassword
char * savedPassword
Definition: pg_backup_archiver.h:275
_archiveHandle::archdbname
char * archdbname
Definition: pg_backup_archiver.h:274
_archiveHandle::DeClonePtr
DeClonePtrType DeClonePtr
Definition: pg_backup_archiver.h:269
_archiveHandle::lookaheadLen
size_t lookaheadLen
Definition: pg_backup_archiver.h:235
_archiveHandle::EndLOsPtr
EndLOsPtrType EndLOsPtr
Definition: pg_backup_archiver.h:259
_archiveHandle::connection
PGconn * connection
Definition: pg_backup_archiver.h:277
_archiveHandle::sync_method
DataDirSyncMethod sync_method
Definition: pg_backup_archiver.h:306
_archiveHandle::lastErrorTE
struct _tocEntry * lastErrorTE
Definition: pg_backup_archiver.h:325
_archiveHandle::writingLO
bool writingLO
Definition: pg_backup_archiver.h:287
_archiveHandle::currSchema
char * currSchema
Definition: pg_backup_archiver.h:312
_archiveHandle::ReadExtraTocPtr
ReadExtraTocPtrType ReadExtraTocPtr
Definition: pg_backup_archiver.h:253
_archiveHandle::archiveDumpVersion
char * archiveDumpVersion
Definition: pg_backup_archiver.h:209
_archiveHandle::currentTE
struct _tocEntry * currentTE
Definition: pg_backup_archiver.h:324
_archiveHandle::OF
void * OF
Definition: pg_backup_archiver.h:292
_archiveHandle::CustomOutPtr
CustomOutPtrType CustomOutPtr
Definition: pg_backup_archiver.h:271
_archiveHandle::mode
ArchiveMode mode
Definition: pg_backup_archiver.h:307