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