#include "postgres_fe.h"
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include "dumputils.h"
#include "fe_utils/string_utils.h"
#include "libpq/libpq-fs.h"
#include "parallel.h"
#include "pg_backup_archiver.h"
#include "pg_backup_db.h"
#include "pg_backup_utils.h"

Include dependency graph for pg_backup_archiver.c:

Data Structures
struct	_outputContext

struct	_parallelReadyList

Macros
#define	TEXT_DUMP_HEADER "--\n-- PostgreSQL database dump\n--\n\n"

#define	TEXT_DUMPALL_HEADER "--\n-- PostgreSQL database cluster dump\n--\n\n"

Typedefs
typedef struct _outputContext	OutputContext

typedef struct _parallelReadyList	ParallelReadyList

Functions
static ArchiveHandle *	_allocAH (const char *FileSpec, const ArchiveFormat fmt, const int compression, bool dosync, ArchiveMode mode, SetupWorkerPtrType setupWorkerPtr)

static void	_getObjectDescription (PQExpBuffer buf, TocEntry te, ArchiveHandle AH)

static void	_printTocEntry (ArchiveHandle AH, TocEntry te, bool isData)

static char *	sanitize_line (const char *str, bool want_hyphen)

static void	_doSetFixedOutputState (ArchiveHandle *AH)

static void	_doSetSessionAuth (ArchiveHandle AH, const char user)

static void	_reconnectToDB (ArchiveHandle AH, const char dbname)

static void	_becomeUser (ArchiveHandle AH, const char user)

static void	_becomeOwner (ArchiveHandle AH, TocEntry te)

static void	_selectOutputSchema (ArchiveHandle AH, const char schemaName)

static void	_selectTablespace (ArchiveHandle AH, const char tablespace)

static void	_selectTableAccessMethod (ArchiveHandle AH, const char tableam)

static void	processEncodingEntry (ArchiveHandle AH, TocEntry te)

static void	processStdStringsEntry (ArchiveHandle AH, TocEntry te)

static void	processSearchPathEntry (ArchiveHandle AH, TocEntry te)

static teReqs	_tocEntryRequired (TocEntry te, teSection curSection, ArchiveHandle AH)

static RestorePass	_tocEntryRestorePass (TocEntry *te)

static bool	_tocEntryIsACL (TocEntry *te)

static void	_disableTriggersIfNecessary (ArchiveHandle AH, TocEntry te)

static void	_enableTriggersIfNecessary (ArchiveHandle AH, TocEntry te)

static void	buildTocEntryArrays (ArchiveHandle *AH)

static void	_moveBefore (ArchiveHandle AH, TocEntry pos, TocEntry *te)

static int	_discoverArchiveFormat (ArchiveHandle *AH)

static int	RestoringToDB (ArchiveHandle *AH)

static void	dump_lo_buf (ArchiveHandle *AH)

static void	dumpTimestamp (ArchiveHandle AH, const char msg, time_t tim)

static void	SetOutput (ArchiveHandle AH, const char filename, int compression)

static OutputContext	SaveOutput (ArchiveHandle *AH)

static void	RestoreOutput (ArchiveHandle *AH, OutputContext savedContext)

static int	restore_toc_entry (ArchiveHandle AH, TocEntry te, bool is_parallel)

static void	restore_toc_entries_prefork (ArchiveHandle AH, TocEntry pending_list)

static void	restore_toc_entries_parallel (ArchiveHandle AH, ParallelState pstate, TocEntry *pending_list)

static void	restore_toc_entries_postfork (ArchiveHandle AH, TocEntry pending_list)

static void	pending_list_header_init (TocEntry *l)

static void	pending_list_append (TocEntry l, TocEntry te)

static void	pending_list_remove (TocEntry *te)

static void	ready_list_init (ParallelReadyList *ready_list, int tocCount)

static void	ready_list_free (ParallelReadyList *ready_list)

static void	ready_list_insert (ParallelReadyList ready_list, TocEntry te)

static void	ready_list_remove (ParallelReadyList *ready_list, int i)

static void	ready_list_sort (ParallelReadyList *ready_list)

static int	TocEntrySizeCompare (const void p1, const void p2)

static void	move_to_ready_list (TocEntry pending_list, ParallelReadyList ready_list, RestorePass pass)

static TocEntry *	pop_next_work_item (ArchiveHandle AH, ParallelReadyList ready_list, ParallelState *pstate)

static void	mark_dump_job_done (ArchiveHandle AH, TocEntry te, int status, void *callback_data)

static void	mark_restore_job_done (ArchiveHandle AH, TocEntry te, int status, void *callback_data)

static void	fix_dependencies (ArchiveHandle *AH)

static bool	has_lock_conflicts (TocEntry te1, TocEntry te2)

static void	repoint_table_dependencies (ArchiveHandle *AH)

static void	identify_locking_dependencies (ArchiveHandle AH, TocEntry te)

static void	reduce_dependencies (ArchiveHandle AH, TocEntry te, ParallelReadyList *ready_list)

static void	mark_create_done (ArchiveHandle AH, TocEntry te)

static void	inhibit_data_for_failed_table (ArchiveHandle AH, TocEntry te)

static void	StrictNamesCheck (RestoreOptions *ropt)

DumpOptions *	NewDumpOptions (void)

void	InitDumpOptions (DumpOptions *opts)

DumpOptions *	dumpOptionsFromRestoreOptions (RestoreOptions *ropt)

static void	setupRestoreWorker (Archive *AHX)

Archive *	CreateArchive (const char *FileSpec, const ArchiveFormat fmt, const int compression, bool dosync, ArchiveMode mode, SetupWorkerPtrType setupDumpWorker)

Archive *	OpenArchive (const char *FileSpec, const ArchiveFormat fmt)

void	CloseArchive (Archive *AHX)

void	SetArchiveOptions (Archive AH, DumpOptions dopt, RestoreOptions *ropt)

void	ProcessArchiveRestoreOptions (Archive *AHX)

void	RestoreArchive (Archive *AHX)

RestoreOptions *	NewRestoreOptions (void)

void	WriteData (Archive AHX, const void data, size_t dLen)

TocEntry *	ArchiveEntry (Archive AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts opts)

void	PrintTOCSummary (Archive *AHX)

int	StartBlob (Archive *AHX, Oid oid)

int	EndBlob (Archive *AHX, Oid oid)

void	StartRestoreBlobs (ArchiveHandle *AH)

void	EndRestoreBlobs (ArchiveHandle *AH)

void	StartRestoreBlob (ArchiveHandle *AH, Oid oid, bool drop)

void	EndRestoreBlob (ArchiveHandle *AH, Oid oid)

void	SortTocFromFile (Archive *AHX)

void	archputs (const char s, Archive AH)

int	archprintf (Archive AH, const char fmt,...)

int	ahprintf (ArchiveHandle AH, const char fmt,...)

void	ahwrite (const void ptr, size_t size, size_t nmemb, ArchiveHandle AH)

void	warn_or_exit_horribly (ArchiveHandle AH, const char fmt,...)

TocEntry *	getTocEntryByDumpId (ArchiveHandle *AH, DumpId id)

teReqs	TocIDRequired (ArchiveHandle *AH, DumpId id)

size_t	WriteOffset (ArchiveHandle *AH, pgoff_t o, int wasSet)

int	ReadOffset (ArchiveHandle AH, pgoff_t o)

size_t	WriteInt (ArchiveHandle *AH, int i)

int	ReadInt (ArchiveHandle *AH)

size_t	WriteStr (ArchiveHandle AH, const char c)

char *	ReadStr (ArchiveHandle *AH)

void	WriteDataChunks (ArchiveHandle AH, ParallelState pstate)

void	WriteDataChunksForTocEntry (ArchiveHandle AH, TocEntry te)

void	WriteToc (ArchiveHandle *AH)

void	ReadToc (ArchiveHandle *AH)

void	WriteHead (ArchiveHandle *AH)

void	ReadHead (ArchiveHandle *AH)

bool	checkSeek (FILE *fp)

int	parallel_restore (ArchiveHandle AH, TocEntry te)

ArchiveHandle *	CloneArchive (ArchiveHandle *AH)

void	DeCloneArchive (ArchiveHandle *AH)

Macro Definition Documentation

◆ TEXT_DUMP_HEADER

#define TEXT_DUMP_HEADER "--\n-- PostgreSQL database dump\n--\n\n"

Definition at line 41 of file pg_backup_archiver.c.

Referenced by _discoverArchiveFormat().

◆ TEXT_DUMPALL_HEADER

#define TEXT_DUMPALL_HEADER "--\n-- PostgreSQL database cluster dump\n--\n\n"

Definition at line 42 of file pg_backup_archiver.c.

Referenced by _discoverArchiveFormat().

Typedef Documentation

◆ OutputContext

typedef struct _outputContext OutputContext

◆ ParallelReadyList

typedef struct _parallelReadyList ParallelReadyList

Function Documentation

◆ _allocAH()

static ArchiveHandle * _allocAH	(	const char *	FileSpec,
		const ArchiveFormat	fmt,
		const int	compression,
		bool	dosync,
		ArchiveMode	mode,
		SetupWorkerPtrType	setupWorkerPtr
	)

static

Definition at line 2275 of file pg_backup_archiver.c.

References _discoverArchiveFormat(), archCustom, archDirectory, _archiveHandle::archiveDumpVersion, archModeWrite, archNull, archTar, archUnknown, _archiveHandle::compression, _archiveHandle::createDate, _archiveHandle::currSchema, _archiveHandle::currTableAm, _archiveHandle::currTablespace, _archiveHandle::currUser, dosync, _archiveHandle::dosync, Archive::encoding, Archive::exit_on_error, fatal, _archiveHandle::format, _archiveHandle::fSpec, _archiveHandle::gzOut, InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), InitArchiveFmt_Null(), InitArchiveFmt_Tar(), _archiveHandle::intSize, K_VERS_SELF, mode, _archiveHandle::mode, Archive::n_errors, _tocEntry::next, _archiveHandle::OF, _archiveHandle::offSize, pg_log_debug, pg_malloc0(), pg_strdup(), pgoff_t, _tocEntry::prev, _archiveHandle::promptPassword, _archiveHandle::public, _archiveHandle::SetupWorkerPtr, _archiveHandle::sqlparse, Archive::std_strings, generate_unaccent_rules::stdout, _archiveHandle::toc, TRI_DEFAULT, and _archiveHandle::version.

Referenced by CreateArchive(), and OpenArchive().

 {
     ArchiveHandle *AH;
 
     pg_log_debug("allocating AH for %s, format %d", FileSpec, fmt);
 
     AH = (ArchiveHandle *) pg_malloc0(sizeof(ArchiveHandle));
 
     AH->version = K_VERS_SELF;
 
     /* initialize for backwards compatible string processing */
     AH->public.encoding = 0;    /* PG_SQL_ASCII */
     AH->public.std_strings = false;
 
     /* sql error handling */
     AH->public.exit_on_error = true;
     AH->public.n_errors = 0;
 
     AH->archiveDumpVersion = PG_VERSION;
 
     AH->createDate = time(NULL);
 
     AH->intSize = sizeof(int);
     AH->offSize = sizeof(pgoff_t);
     if (FileSpec)
     {
         AH->fSpec = pg_strdup(FileSpec);
 
         /*
          * Not used; maybe later....
          *
          * AH->workDir = pg_strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
          * i--) if (AH->workDir[i-1] == '/')
          */
     }
     else
         AH->fSpec = NULL;
 
     AH->currUser = NULL;        /* unknown */
     AH->currSchema = NULL;      /* ditto */
     AH->currTablespace = NULL;  /* ditto */
     AH->currTableAm = NULL;     /* ditto */
 
     AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
     AH->toc->next = AH->toc;
     AH->toc->prev = AH->toc;
 
     AH->mode = mode;
     AH->compression = compression;
     AH->dosync = dosync;
 
     memset(&(AH->sqlparse), 0, sizeof(AH->sqlparse));
 
     /* Open stdout with no compression for AH output handle */
     AH->gzOut = 0;
     AH->OF = stdout;
 
     /*
      * On Windows, we need to use binary mode to read/write non-text files,
      * which include all archive formats as well as compressed plain text.
      * Force stdin/stdout into binary mode if that is what we are using.
      */
 #ifdef WIN32
     if ((fmt != archNull || compression != 0) &&
         (AH->fSpec == NULL || strcmp(AH->fSpec, "") == 0))
     {
         if (mode == archModeWrite)
             _setmode(fileno(stdout), O_BINARY);
         else
             _setmode(fileno(stdin), O_BINARY);
     }
 #endif
 
     AH->SetupWorkerPtr = setupWorkerPtr;
 
     if (fmt == archUnknown)
         AH->format = _discoverArchiveFormat(AH);
     else
         AH->format = fmt;
 
     AH->promptPassword = TRI_DEFAULT;
 
     switch (AH->format)
     {
         case archCustom:
             InitArchiveFmt_Custom(AH);
             break;
 
         case archNull:
             InitArchiveFmt_Null(AH);
             break;
 
         case archDirectory:
             InitArchiveFmt_Directory(AH);
             break;
 
         case archTar:
             InitArchiveFmt_Tar(AH);
             break;
 
         default:
             fatal("unrecognized file format \"%d\"", fmt);
     }
 
     return AH;
 }

◆ _becomeOwner()

static void _becomeOwner	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 3281 of file pg_backup_archiver.c.

References _becomeUser(), _restoreOptions::noOwner, _tocEntry::owner, _archiveHandle::public, Archive::ropt, and _restoreOptions::use_setsessauth.

Referenced by _printTocEntry(), restore_toc_entry(), and RestoreArchive().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     if (ropt && (ropt->noOwner || !ropt->use_setsessauth))
         return;
 
     _becomeUser(AH, te->owner);
 }

◆ _becomeUser()

static void _becomeUser	(	ArchiveHandle *	AH,
		const char *	user
	)

static

Definition at line 3257 of file pg_backup_archiver.c.

References _doSetSessionAuth(), _archiveHandle::currUser, free, and pg_strdup().

Referenced by _becomeOwner(), _disableTriggersIfNecessary(), and _enableTriggersIfNecessary().

 {
     if (!user)
         user = "";              /* avoid null pointers */
 
     if (AH->currUser && strcmp(AH->currUser, user) == 0)
         return;                 /* no need to do anything */
 
     _doSetSessionAuth(AH, user);
 
     /*
      * NOTE: currUser keeps track of what the imaginary session user in our
      * script is
      */
     if (AH->currUser)
         free(AH->currUser);
     AH->currUser = pg_strdup(user);
 }

◆ _disableTriggersIfNecessary()

static void _disableTriggersIfNecessary	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 983 of file pg_backup_archiver.c.

References _becomeUser(), ahprintf(), _restoreOptions::dataOnly, _restoreOptions::disable_triggers, fmtQualifiedId(), pg_log_info, _archiveHandle::public, Archive::ropt, _restoreOptions::superuser, and _tocEntry::tag.

Referenced by restore_toc_entry().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     /* This hack is only needed in a data-only restore */
     if (!ropt->dataOnly || !ropt->disable_triggers)
         return;
 
     pg_log_info("disabling triggers for %s", te->tag);
 
     /*
      * Become superuser if possible, since they are the only ones who can
      * disable constraint triggers.  If -S was not given, assume the initial
      * user identity is a superuser.  (XXX would it be better to become the
      * table owner?)
      */
     _becomeUser(AH, ropt->superuser);
 
     /*
      * Disable them.
      */
     ahprintf(AH, "ALTER TABLE %s DISABLE TRIGGER ALL;\n\n",
              fmtQualifiedId(te->namespace, te->tag));
 }

◆ _discoverArchiveFormat()

static int _discoverArchiveFormat ( ArchiveHandle * AH )

static

Definition at line 2075 of file pg_backup_archiver.c.

References archDirectory, archTar, buf, fatal, _archiveHandle::format, free, fseeko, _archiveHandle::fSpec, _archiveHandle::intSize, isValidTarHeader(), K_VERS_1_7, _archiveHandle::lookahead, _archiveHandle::lookaheadLen, _archiveHandle::lookaheadPos, _archiveHandle::lookaheadSize, MAKE_ARCHIVE_VERSION, MAXPGPATH, _archiveHandle::offSize, PG_BINARY_R, pg_log_debug, pg_malloc0(), READ_ERROR_EXIT, _archiveHandle::readHeader, S_ISDIR, S_ISREG, sig, snprintf, stat, TEXT_DUMP_HEADER, TEXT_DUMPALL_HEADER, and _archiveHandle::version.

Referenced by _allocAH().

 {
     FILE       *fh;
     char        sig[6];         /* More than enough */
     size_t      cnt;
     int         wantClose = 0;
 
     pg_log_debug("attempting to ascertain archive format");
 
     if (AH->lookahead)
         free(AH->lookahead);
 
     AH->lookaheadSize = 512;
     AH->lookahead = pg_malloc0(512);
     AH->lookaheadLen = 0;
     AH->lookaheadPos = 0;
 
     if (AH->fSpec)
     {
         struct stat st;
 
         wantClose = 1;
 
         /*
          * Check if the specified archive is a directory. If so, check if
          * there's a "toc.dat" (or "toc.dat.gz") file in it.
          */
         if (stat(AH->fSpec, &st) == 0 && S_ISDIR(st.st_mode))
         {
             char        buf[MAXPGPATH];
 
             if (snprintf(buf, MAXPGPATH, "%s/toc.dat", AH->fSpec) >= MAXPGPATH)
                 fatal("directory name too long: \"%s\"",
                       AH->fSpec);
             if (stat(buf, &st) == 0 && S_ISREG(st.st_mode))
             {
                 AH->format = archDirectory;
                 return AH->format;
             }
 
 #ifdef HAVE_LIBZ
             if (snprintf(buf, MAXPGPATH, "%s/toc.dat.gz", AH->fSpec) >= MAXPGPATH)
                 fatal("directory name too long: \"%s\"",
                       AH->fSpec);
             if (stat(buf, &st) == 0 && S_ISREG(st.st_mode))
             {
                 AH->format = archDirectory;
                 return AH->format;
             }
 #endif
             fatal("directory \"%s\" does not appear to be a valid archive (\"toc.dat\" does not exist)",
                   AH->fSpec);
             fh = NULL;          /* keep compiler quiet */
         }
         else
         {
             fh = fopen(AH->fSpec, PG_BINARY_R);
             if (!fh)
                 fatal("could not open input file \"%s\": %m", AH->fSpec);
         }
     }
     else
     {
         fh = stdin;
         if (!fh)
             fatal("could not open input file: %m");
     }
 
     if ((cnt = fread(sig, 1, 5, fh)) != 5)
     {
         if (ferror(fh))
             fatal("could not read input file: %m");
         else
             fatal("input file is too short (read %lu, expected 5)",
                   (unsigned long) cnt);
     }
 
     /* Save it, just in case we need it later */
     memcpy(&AH->lookahead[0], sig, 5);
     AH->lookaheadLen = 5;
 
     if (strncmp(sig, "PGDMP", 5) == 0)
     {
         int         byteread;
         char        vmaj,
                     vmin,
                     vrev;
 
         /*
          * Finish reading (most of) a custom-format header.
          *
          * NB: this code must agree with ReadHead().
          */
         if ((byteread = fgetc(fh)) == EOF)
             READ_ERROR_EXIT(fh);
 
         vmaj = byteread;
 
         if ((byteread = fgetc(fh)) == EOF)
             READ_ERROR_EXIT(fh);
 
         vmin = byteread;
 
         /* Save these too... */
         AH->lookahead[AH->lookaheadLen++] = vmaj;
         AH->lookahead[AH->lookaheadLen++] = vmin;
 
         /* Check header version; varies from V1.0 */
         if (vmaj > 1 || (vmaj == 1 && vmin > 0))    /* Version > 1.0 */
         {
             if ((byteread = fgetc(fh)) == EOF)
                 READ_ERROR_EXIT(fh);
 
             vrev = byteread;
             AH->lookahead[AH->lookaheadLen++] = vrev;
         }
         else
             vrev = 0;
 
         AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
 
         if ((AH->intSize = fgetc(fh)) == EOF)
             READ_ERROR_EXIT(fh);
         AH->lookahead[AH->lookaheadLen++] = AH->intSize;
 
         if (AH->version >= K_VERS_1_7)
         {
             if ((AH->offSize = fgetc(fh)) == EOF)
                 READ_ERROR_EXIT(fh);
             AH->lookahead[AH->lookaheadLen++] = AH->offSize;
         }
         else
             AH->offSize = AH->intSize;
 
         if ((byteread = fgetc(fh)) == EOF)
             READ_ERROR_EXIT(fh);
 
         AH->format = byteread;
         AH->lookahead[AH->lookaheadLen++] = AH->format;
     }
     else
     {
         /*
          * *Maybe* we have a tar archive format file or a text dump ... So,
          * read first 512 byte header...
          */
         cnt = fread(&AH->lookahead[AH->lookaheadLen], 1, 512 - AH->lookaheadLen, fh);
         /* read failure is checked below */
         AH->lookaheadLen += cnt;
 
         if (AH->lookaheadLen >= strlen(TEXT_DUMPALL_HEADER) &&
             (strncmp(AH->lookahead, TEXT_DUMP_HEADER, strlen(TEXT_DUMP_HEADER)) == 0 ||
              strncmp(AH->lookahead, TEXT_DUMPALL_HEADER, strlen(TEXT_DUMPALL_HEADER)) == 0))
         {
             /*
              * looks like it's probably a text format dump. so suggest they
              * try psql
              */
             fatal("input file appears to be a text format dump. Please use psql.");
         }
 
         if (AH->lookaheadLen != 512)
         {
             if (feof(fh))
                 fatal("input file does not appear to be a valid archive (too short?)");
             else
                 READ_ERROR_EXIT(fh);
         }
 
         if (!isValidTarHeader(AH->lookahead))
             fatal("input file does not appear to be a valid archive");
 
         AH->format = archTar;
     }
 
     /* If we can't seek, then mark the header as read */
     if (fseeko(fh, 0, SEEK_SET) != 0)
     {
         /*
          * NOTE: Formats that use the lookahead buffer can unset this in their
          * Init routine.
          */
         AH->readHeader = 1;
     }
     else
         AH->lookaheadLen = 0;   /* Don't bother since we've reset the file */
 
     /* Close the file */
     if (wantClose)
         if (fclose(fh) != 0)
             fatal("could not close input file: %m");
 
     return AH->format;
 }

◆ _doSetFixedOutputState()

static void _doSetFixedOutputState ( ArchiveHandle * AH )

static

Definition at line 3114 of file pg_backup_archiver.c.

References ahprintf(), _restoreOptions::enable_row_security, Archive::encoding, fmtId(), pg_encoding_to_char(), _archiveHandle::public, Archive::ropt, Archive::searchpath, Archive::std_strings, and _restoreOptions::use_role.

Referenced by _reconnectToDB(), CloneArchive(), restore_toc_entries_postfork(), and RestoreArchive().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     /*
      * Disable timeouts to allow for slow commands, idle parallel workers, etc
      */
     ahprintf(AH, "SET statement_timeout = 0;\n");
     ahprintf(AH, "SET lock_timeout = 0;\n");
     ahprintf(AH, "SET idle_in_transaction_session_timeout = 0;\n");
 
     /* Select the correct character set encoding */
     ahprintf(AH, "SET client_encoding = '%s';\n",
              pg_encoding_to_char(AH->public.encoding));
 
     /* Select the correct string literal syntax */
     ahprintf(AH, "SET standard_conforming_strings = %s;\n",
              AH->public.std_strings ? "on" : "off");
 
     /* Select the role to be used during restore */
     if (ropt && ropt->use_role)
         ahprintf(AH, "SET ROLE %s;\n", fmtId(ropt->use_role));
 
     /* Select the dump-time search_path */
     if (AH->public.searchpath)
         ahprintf(AH, "%s", AH->public.searchpath);
 
     /* Make sure function checking is disabled */
     ahprintf(AH, "SET check_function_bodies = false;\n");
 
     /* Ensure that all valid XML data will be accepted */
     ahprintf(AH, "SET xmloption = content;\n");
 
     /* Avoid annoying notices etc */
     ahprintf(AH, "SET client_min_messages = warning;\n");
     if (!AH->public.std_strings)
         ahprintf(AH, "SET escape_string_warning = off;\n");
 
     /* Adjust row-security state */
     if (ropt && ropt->enable_row_security)
         ahprintf(AH, "SET row_security = on;\n");
     else
         ahprintf(AH, "SET row_security = off;\n");
 
     ahprintf(AH, "\n");
 }

◆ _doSetSessionAuth()

static void _doSetSessionAuth	(	ArchiveHandle *	AH,
		const char *	user
	)

static

Definition at line 3167 of file pg_backup_archiver.c.

References ahprintf(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAHX, _archiveHandle::connection, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), fatal, PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQexec(), PQresultStatus(), and RestoringToDB().

Referenced by _becomeUser().

 {
     PQExpBuffer cmd = createPQExpBuffer();
 
     appendPQExpBufferStr(cmd, "SET SESSION AUTHORIZATION ");
 
     /*
      * SQL requires a string literal here.  Might as well be correct.
      */
     if (user && *user)
         appendStringLiteralAHX(cmd, user, AH);
     else
         appendPQExpBufferStr(cmd, "DEFAULT");
     appendPQExpBufferChar(cmd, ';');
 
     if (RestoringToDB(AH))
     {
         PGresult   *res;
 
         res = PQexec(AH->connection, cmd->data);
 
         if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
             /* NOT warn_or_exit_horribly... use -O instead to skip this. */
             fatal("could not set session user to \"%s\": %s",
                   user, PQerrorMessage(AH->connection));
 
         PQclear(res);
     }
     else
         ahprintf(AH, "%s\n\n", cmd->data);
 
     destroyPQExpBuffer(cmd);
 }

◆ _enableTriggersIfNecessary()

static void _enableTriggersIfNecessary	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 1009 of file pg_backup_archiver.c.

References _becomeUser(), ahprintf(), _restoreOptions::dataOnly, _restoreOptions::disable_triggers, fmtQualifiedId(), pg_log_info, _archiveHandle::public, Archive::ropt, _restoreOptions::superuser, and _tocEntry::tag.

Referenced by restore_toc_entry().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     /* This hack is only needed in a data-only restore */
     if (!ropt->dataOnly || !ropt->disable_triggers)
         return;
 
     pg_log_info("enabling triggers for %s", te->tag);
 
     /*
      * Become superuser if possible, since they are the only ones who can
      * disable constraint triggers.  If -S was not given, assume the initial
      * user identity is a superuser.  (XXX would it be better to become the
      * table owner?)
      */
     _becomeUser(AH, ropt->superuser);
 
     /*
      * Enable them.
      */
     ahprintf(AH, "ALTER TABLE %s ENABLE TRIGGER ALL;\n\n",
              fmtQualifiedId(te->namespace, te->tag));
 }

◆ _getObjectDescription()

static void _getObjectDescription	(	PQExpBuffer	buf,
		TocEntry *	te,
		ArchiveHandle *	AH
	)

static

Definition at line 3455 of file pg_backup_archiver.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), _tocEntry::desc, _tocEntry::dropStmt, fmtId(), free, pg_log_warning, pg_strdup(), _tocEntry::tag, and generate_unaccent_rules::type.

Referenced by _printTocEntry().

 {
     const char *type = te->desc;
 
     /* Use ALTER TABLE for views and sequences */
     if (strcmp(type, "VIEW") == 0 || strcmp(type, "SEQUENCE") == 0 ||
         strcmp(type, "MATERIALIZED VIEW") == 0)
         type = "TABLE";
 
     /* objects that don't require special decoration */
     if (strcmp(type, "COLLATION") == 0 ||
         strcmp(type, "CONVERSION") == 0 ||
         strcmp(type, "DOMAIN") == 0 ||
         strcmp(type, "TABLE") == 0 ||
         strcmp(type, "TYPE") == 0 ||
         strcmp(type, "FOREIGN TABLE") == 0 ||
         strcmp(type, "TEXT SEARCH DICTIONARY") == 0 ||
         strcmp(type, "TEXT SEARCH CONFIGURATION") == 0 ||
         strcmp(type, "STATISTICS") == 0 ||
     /* non-schema-specified objects */
         strcmp(type, "DATABASE") == 0 ||
         strcmp(type, "PROCEDURAL LANGUAGE") == 0 ||
         strcmp(type, "SCHEMA") == 0 ||
         strcmp(type, "EVENT TRIGGER") == 0 ||
         strcmp(type, "FOREIGN DATA WRAPPER") == 0 ||
         strcmp(type, "SERVER") == 0 ||
         strcmp(type, "PUBLICATION") == 0 ||
         strcmp(type, "SUBSCRIPTION") == 0 ||
         strcmp(type, "USER MAPPING") == 0)
     {
         appendPQExpBuffer(buf, "%s ", type);
         if (te->namespace && *te->namespace)
             appendPQExpBuffer(buf, "%s.", fmtId(te->namespace));
         appendPQExpBufferStr(buf, fmtId(te->tag));
         return;
     }
 
     /* BLOBs just have a name, but it's numeric so must not use fmtId */
     if (strcmp(type, "BLOB") == 0)
     {
         appendPQExpBuffer(buf, "LARGE OBJECT %s", te->tag);
         return;
     }
 
     /*
      * These object types require additional decoration.  Fortunately, the
      * information needed is exactly what's in the DROP command.
      */
     if (strcmp(type, "AGGREGATE") == 0 ||
         strcmp(type, "FUNCTION") == 0 ||
         strcmp(type, "OPERATOR") == 0 ||
         strcmp(type, "OPERATOR CLASS") == 0 ||
         strcmp(type, "OPERATOR FAMILY") == 0 ||
         strcmp(type, "PROCEDURE") == 0)
     {
         /* Chop "DROP " off the front and make a modifiable copy */
         char       *first = pg_strdup(te->dropStmt + 5);
         char       *last;
 
         /* point to last character in string */
         last = first + strlen(first) - 1;
 
         /* Strip off any ';' or '\n' at the end */
         while (last >= first && (*last == '\n' || *last == ';'))
             last--;
         *(last + 1) = '\0';
 
         appendPQExpBufferStr(buf, first);
 
         free(first);
         return;
     }
 
     pg_log_warning("don't know how to set owner for object type \"%s\"",
                    type);
 }

◆ _moveBefore()

static void _moveBefore	(	ArchiveHandle *	AH,
		TocEntry *	pos,
		TocEntry *	te
	)

static

Definition at line 1807 of file pg_backup_archiver.c.

References _tocEntry::next, and _tocEntry::prev.

Referenced by SortTocFromFile().

 {
     /* Unlink te from list */
     te->prev->next = te->next;
     te->next->prev = te->prev;
 
     /* and insert it before "pos" */
     te->prev = pos->prev;
     te->next = pos;
     pos->prev->next = te;
     pos->prev = te;
 }

◆ _printTocEntry()

static void _printTocEntry	(	ArchiveHandle *	AH,
		TocEntry *	te,
		bool	isData
	)

static

Definition at line 3540 of file pg_backup_archiver.c.

References _becomeOwner(), _getObjectDescription(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), _tocEntryIsACL(), ahprintf(), appendPQExpBuffer(), appendPQExpBufferStr(), _tocEntry::catalogId, createPQExpBuffer(), _archiveHandle::currUser, PQExpBufferData::data, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, destroyPQExpBuffer(), _tocEntry::dropStmt, _tocEntry::dumpId, fmtId(), free, i, _tocEntry::nDeps, _restoreOptions::noOwner, _restoreOptions::noTablespace, _archiveHandle::noTocComments, CatalogId::oid, _tocEntry::owner, pg_log_warning, _archiveHandle::PrintExtraTocPtr, _archiveHandle::public, Archive::ropt, sanitize_line(), _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _restoreOptions::use_setsessauth, and Archive::verbose.

Referenced by restore_toc_entry().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     /* Select owner, schema, tablespace and default AM as necessary */
     _becomeOwner(AH, te);
     _selectOutputSchema(AH, te->namespace);
     _selectTablespace(AH, te->tablespace);
     _selectTableAccessMethod(AH, te->tableam);
 
     /* Emit header comment for item */
     if (!AH->noTocComments)
     {
         const char *pfx;
         char       *sanitized_name;
         char       *sanitized_schema;
         char       *sanitized_owner;
 
         if (isData)
             pfx = "Data for ";
         else
             pfx = "";
 
         ahprintf(AH, "--\n");
         if (AH->public.verbose)
         {
             ahprintf(AH, "-- TOC entry %d (class %u OID %u)\n",
                      te->dumpId, te->catalogId.tableoid, te->catalogId.oid);
             if (te->nDeps > 0)
             {
                 int         i;
 
                 ahprintf(AH, "-- Dependencies:");
                 for (i = 0; i < te->nDeps; i++)
                     ahprintf(AH, " %d", te->dependencies[i]);
                 ahprintf(AH, "\n");
             }
         }
 
         sanitized_name = sanitize_line(te->tag, false);
         sanitized_schema = sanitize_line(te->namespace, true);
         sanitized_owner = sanitize_line(ropt->noOwner ? NULL : te->owner, true);
 
         ahprintf(AH, "-- %sName: %s; Type: %s; Schema: %s; Owner: %s",
                  pfx, sanitized_name, te->desc, sanitized_schema,
                  sanitized_owner);
 
         free(sanitized_name);
         free(sanitized_schema);
         free(sanitized_owner);
 
         if (te->tablespace && strlen(te->tablespace) > 0 && !ropt->noTablespace)
         {
             char       *sanitized_tablespace;
 
             sanitized_tablespace = sanitize_line(te->tablespace, false);
             ahprintf(AH, "; Tablespace: %s", sanitized_tablespace);
             free(sanitized_tablespace);
         }
         ahprintf(AH, "\n");
 
         if (AH->PrintExtraTocPtr != NULL)
             AH->PrintExtraTocPtr(AH, te);
         ahprintf(AH, "--\n\n");
     }
 
     /*
      * Actually print the definition.
      *
      * Really crude hack for suppressing AUTHORIZATION clause that old pg_dump
      * versions put into CREATE SCHEMA.  We have to do this when --no-owner
      * mode is selected.  This is ugly, but I see no other good way ...
      */
     if (ropt->noOwner && strcmp(te->desc, "SCHEMA") == 0)
     {
         ahprintf(AH, "CREATE SCHEMA %s;\n\n\n", fmtId(te->tag));
     }
     else
     {
         if (te->defn && strlen(te->defn) > 0)
             ahprintf(AH, "%s\n\n", te->defn);
     }
 
     /*
      * If we aren't using SET SESSION AUTH to determine ownership, we must
      * instead issue an ALTER OWNER command.  We assume that anything without
      * a DROP command is not a separately ownable object.  All the categories
      * with DROP commands must appear in one list or the other.
      */
     if (!ropt->noOwner && !ropt->use_setsessauth &&
         te->owner && strlen(te->owner) > 0 &&
         te->dropStmt && strlen(te->dropStmt) > 0)
     {
         if (strcmp(te->desc, "AGGREGATE") == 0 ||
             strcmp(te->desc, "BLOB") == 0 ||
             strcmp(te->desc, "COLLATION") == 0 ||
             strcmp(te->desc, "CONVERSION") == 0 ||
             strcmp(te->desc, "DATABASE") == 0 ||
             strcmp(te->desc, "DOMAIN") == 0 ||
             strcmp(te->desc, "FUNCTION") == 0 ||
             strcmp(te->desc, "OPERATOR") == 0 ||
             strcmp(te->desc, "OPERATOR CLASS") == 0 ||
             strcmp(te->desc, "OPERATOR FAMILY") == 0 ||
             strcmp(te->desc, "PROCEDURE") == 0 ||
             strcmp(te->desc, "PROCEDURAL LANGUAGE") == 0 ||
             strcmp(te->desc, "SCHEMA") == 0 ||
             strcmp(te->desc, "EVENT TRIGGER") == 0 ||
             strcmp(te->desc, "TABLE") == 0 ||
             strcmp(te->desc, "TYPE") == 0 ||
             strcmp(te->desc, "VIEW") == 0 ||
             strcmp(te->desc, "MATERIALIZED VIEW") == 0 ||
             strcmp(te->desc, "SEQUENCE") == 0 ||
             strcmp(te->desc, "FOREIGN TABLE") == 0 ||
             strcmp(te->desc, "TEXT SEARCH DICTIONARY") == 0 ||
             strcmp(te->desc, "TEXT SEARCH CONFIGURATION") == 0 ||
             strcmp(te->desc, "FOREIGN DATA WRAPPER") == 0 ||
             strcmp(te->desc, "SERVER") == 0 ||
             strcmp(te->desc, "STATISTICS") == 0 ||
             strcmp(te->desc, "PUBLICATION") == 0 ||
             strcmp(te->desc, "SUBSCRIPTION") == 0)
         {
             PQExpBuffer temp = createPQExpBuffer();
 
             appendPQExpBufferStr(temp, "ALTER ");
             _getObjectDescription(temp, te, AH);
             appendPQExpBuffer(temp, " OWNER TO %s;", fmtId(te->owner));
             ahprintf(AH, "%s\n\n", temp->data);
             destroyPQExpBuffer(temp);
         }
         else if (strcmp(te->desc, "CAST") == 0 ||
                  strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
                  strcmp(te->desc, "CONSTRAINT") == 0 ||
                  strcmp(te->desc, "DATABASE PROPERTIES") == 0 ||
                  strcmp(te->desc, "DEFAULT") == 0 ||
                  strcmp(te->desc, "FK CONSTRAINT") == 0 ||
                  strcmp(te->desc, "INDEX") == 0 ||
                  strcmp(te->desc, "RULE") == 0 ||
                  strcmp(te->desc, "TRIGGER") == 0 ||
                  strcmp(te->desc, "ROW SECURITY") == 0 ||
                  strcmp(te->desc, "POLICY") == 0 ||
                  strcmp(te->desc, "USER MAPPING") == 0)
         {
             /* these object types don't have separate owners */
         }
         else
         {
             pg_log_warning("don't know how to set owner for object type \"%s\"",
                            te->desc);
         }
     }
 
     /*
      * If it's an ACL entry, it might contain SET SESSION AUTHORIZATION
      * commands, so we can no longer assume we know the current auth setting.
      */
     if (_tocEntryIsACL(te))
     {
         if (AH->currUser)
             free(AH->currUser);
         AH->currUser = NULL;
     }
 }

◆ _reconnectToDB()

static void _reconnectToDB	(	ArchiveHandle *	AH,
		const char *	dbname
	)

static

Definition at line 3212 of file pg_backup_archiver.c.

References _doSetFixedOutputState(), ahprintf(), appendPsqlMetaConnect(), _archiveHandle::currSchema, _archiveHandle::currTablespace, _archiveHandle::currUser, PQExpBufferData::data, free, initPQExpBuffer(), ReconnectToServer(), RestoringToDB(), and termPQExpBuffer().

Referenced by restore_toc_entry().

 {
     if (RestoringToDB(AH))
         ReconnectToServer(AH, dbname, NULL);
     else
     {
         if (dbname)
         {
             PQExpBufferData connectbuf;
 
             initPQExpBuffer(&connectbuf);
             appendPsqlMetaConnect(&connectbuf, dbname);
             ahprintf(AH, "%s\n", connectbuf.data);
             termPQExpBuffer(&connectbuf);
         }
         else
             ahprintf(AH, "%s\n", "\\connect -\n");
     }
 
     /*
      * NOTE: currUser keeps track of what the imaginary session user in our
      * script is.  It's now effectively reset to the original userID.
      */
     if (AH->currUser)
         free(AH->currUser);
     AH->currUser = NULL;
 
     /* don't assume we still know the output schema, tablespace, etc either */
     if (AH->currSchema)
         free(AH->currSchema);
     AH->currSchema = NULL;
     if (AH->currTablespace)
         free(AH->currTablespace);
     AH->currTablespace = NULL;
 
     /* re-establish fixed state */
     _doSetFixedOutputState(AH);
 }

◆ _selectOutputSchema()

static void _selectOutputSchema	(	ArchiveHandle *	AH,
		const char *	schemaName
	)

static

Definition at line 3297 of file pg_backup_archiver.c.

References ahprintf(), appendPQExpBuffer(), appendPQExpBufferStr(), _archiveHandle::connection, createPQExpBuffer(), _archiveHandle::currSchema, PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), free, pg_strdup(), PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQexec(), PQresultStatus(), _archiveHandle::public, RestoringToDB(), Archive::searchpath, and warn_or_exit_horribly().

Referenced by _printTocEntry(), restore_toc_entry(), and RestoreArchive().

 {
     PQExpBuffer qry;
 
     /*
      * If there was a SEARCHPATH TOC entry, we're supposed to just stay with
      * that search_path rather than switching to entry-specific paths.
      * Otherwise, it's an old archive that will not restore correctly unless
      * we set the search_path as it's expecting.
      */
     if (AH->public.searchpath)
         return;
 
     if (!schemaName || *schemaName == '\0' ||
         (AH->currSchema && strcmp(AH->currSchema, schemaName) == 0))
         return;                 /* no need to do anything */
 
     qry = createPQExpBuffer();
 
     appendPQExpBuffer(qry, "SET search_path = %s",
                       fmtId(schemaName));
     if (strcmp(schemaName, "pg_catalog") != 0)
         appendPQExpBufferStr(qry, ", pg_catalog");
 
     if (RestoringToDB(AH))
     {
         PGresult   *res;
 
         res = PQexec(AH->connection, qry->data);
 
         if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
             warn_or_exit_horribly(AH,
                                   "could not set search_path to \"%s\": %s",
                                   schemaName, PQerrorMessage(AH->connection));
 
         PQclear(res);
     }
     else
         ahprintf(AH, "%s;\n\n", qry->data);
 
     if (AH->currSchema)
         free(AH->currSchema);
     AH->currSchema = pg_strdup(schemaName);
 
     destroyPQExpBuffer(qry);
 }

◆ _selectTableAccessMethod()

static void _selectTableAccessMethod	(	ArchiveHandle *	AH,
		const char *	tableam
	)

static

Definition at line 3410 of file pg_backup_archiver.c.

References ahprintf(), appendPQExpBuffer(), _archiveHandle::connection, createPQExpBuffer(), _archiveHandle::currTableAm, PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), pg_strdup(), PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQexec(), PQresultStatus(), RestoringToDB(), and warn_or_exit_horribly().

Referenced by _printTocEntry().

 {
     PQExpBuffer cmd;
     const char *want,
                *have;
 
     have = AH->currTableAm;
     want = tableam;
 
     if (!want)
         return;
 
     if (have && strcmp(want, have) == 0)
         return;
 
     cmd = createPQExpBuffer();
     appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", fmtId(want));
 
     if (RestoringToDB(AH))
     {
         PGresult   *res;
 
         res = PQexec(AH->connection, cmd->data);
 
         if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
             warn_or_exit_horribly(AH,
                                   "could not set default_table_access_method: %s",
                                   PQerrorMessage(AH->connection));
 
         PQclear(res);
     }
     else
         ahprintf(AH, "%s\n\n", cmd->data);
 
     destroyPQExpBuffer(cmd);
 
     AH->currTableAm = pg_strdup(want);
 }

◆ _selectTablespace()

static void _selectTablespace	(	ArchiveHandle *	AH,
		const char *	tablespace
	)

static

Definition at line 3349 of file pg_backup_archiver.c.

References ahprintf(), appendPQExpBuffer(), appendPQExpBufferStr(), _archiveHandle::connection, createPQExpBuffer(), _archiveHandle::currTablespace, PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), free, _restoreOptions::noTablespace, pg_strdup(), PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQexec(), PQresultStatus(), _archiveHandle::public, RestoringToDB(), Archive::ropt, tablespace, and warn_or_exit_horribly().

Referenced by _printTocEntry().

 {
     RestoreOptions *ropt = AH->public.ropt;
     PQExpBuffer qry;
     const char *want,
                *have;
 
     /* do nothing in --no-tablespaces mode */
     if (ropt->noTablespace)
         return;
 
     have = AH->currTablespace;
     want = tablespace;
 
     /* no need to do anything for non-tablespace object */
     if (!want)
         return;
 
     if (have && strcmp(want, have) == 0)
         return;                 /* no need to do anything */
 
     qry = createPQExpBuffer();
 
     if (strcmp(want, "") == 0)
     {
         /* We want the tablespace to be the database's default */
         appendPQExpBufferStr(qry, "SET default_tablespace = ''");
     }
     else
     {
         /* We want an explicit tablespace */
         appendPQExpBuffer(qry, "SET default_tablespace = %s", fmtId(want));
     }
 
     if (RestoringToDB(AH))
     {
         PGresult   *res;
 
         res = PQexec(AH->connection, qry->data);
 
         if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
             warn_or_exit_horribly(AH,
                                   "could not set default_tablespace to %s: %s",
                                   fmtId(want), PQerrorMessage(AH->connection));
 
         PQclear(res);
     }
     else
         ahprintf(AH, "%s;\n\n", qry->data);
 
     if (AH->currTablespace)
         free(AH->currTablespace);
     AH->currTablespace = pg_strdup(want);
 
     destroyPQExpBuffer(qry);
 }

◆ _tocEntryIsACL()

static bool _tocEntryIsACL ( TocEntry * te )

static

Definition at line 3099 of file pg_backup_archiver.c.

References _tocEntry::desc.

Referenced by _printTocEntry(), and _tocEntryRequired().

 {
     /* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */
     if (strcmp(te->desc, "ACL") == 0 ||
         strcmp(te->desc, "ACL LANGUAGE") == 0 ||
         strcmp(te->desc, "DEFAULT ACL") == 0)
         return true;
     return false;
 }

◆ _tocEntryRequired()

static teReqs _tocEntryRequired	(	TocEntry *	te,
		teSection	curSection,
		ArchiveHandle *	AH
	)

static

Definition at line 2822 of file pg_backup_archiver.c.

Referenced by PrintTOCSummary(), and ProcessArchiveRestoreOptions().

 {
     teReqs      res = REQ_SCHEMA | REQ_DATA;
     RestoreOptions *ropt = AH->public.ropt;
 
     /* These items are treated specially */
     if (strcmp(te->desc, "ENCODING") == 0 ||
         strcmp(te->desc, "STDSTRINGS") == 0 ||
         strcmp(te->desc, "SEARCHPATH") == 0)
         return REQ_SPECIAL;
 
     /*
      * DATABASE and DATABASE PROPERTIES also have a special rule: they are
      * restored in createDB mode, and not restored otherwise, independently of
      * all else.
      */
     if (strcmp(te->desc, "DATABASE") == 0 ||
         strcmp(te->desc, "DATABASE PROPERTIES") == 0)
     {
         if (ropt->createDB)
             return REQ_SCHEMA;
         else
             return 0;
     }
 
     /*
      * Process exclusions that affect certain classes of TOC entries.
      */
 
     /* If it's an ACL, maybe ignore it */
     if (ropt->aclsSkip && _tocEntryIsACL(te))
         return 0;
 
     /* If it's a comment, maybe ignore it */
     if (ropt->no_comments && strcmp(te->desc, "COMMENT") == 0)
         return 0;
 
     /*
      * If it's a publication or a table part of a publication, maybe ignore
      * it.
      */
     if (ropt->no_publications &&
         (strcmp(te->desc, "PUBLICATION") == 0 ||
          strcmp(te->desc, "PUBLICATION TABLE") == 0))
         return 0;
 
     /* If it's a security label, maybe ignore it */
     if (ropt->no_security_labels && strcmp(te->desc, "SECURITY LABEL") == 0)
         return 0;
 
     /* If it's a subscription, maybe ignore it */
     if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION") == 0)
         return 0;
 
     /* Ignore it if section is not to be dumped/restored */
     switch (curSection)
     {
         case SECTION_PRE_DATA:
             if (!(ropt->dumpSections & DUMP_PRE_DATA))
                 return 0;
             break;
         case SECTION_DATA:
             if (!(ropt->dumpSections & DUMP_DATA))
                 return 0;
             break;
         case SECTION_POST_DATA:
             if (!(ropt->dumpSections & DUMP_POST_DATA))
                 return 0;
             break;
         default:
             /* shouldn't get here, really, but ignore it */
             return 0;
     }
 
     /* Ignore it if rejected by idWanted[] (cf. SortTocFromFile) */
     if (ropt->idWanted && !ropt->idWanted[te->dumpId - 1])
         return 0;
 
     /*
      * Check options for selective dump/restore.
      */
     if (strcmp(te->desc, "ACL") == 0 ||
         strcmp(te->desc, "COMMENT") == 0 ||
         strcmp(te->desc, "SECURITY LABEL") == 0)
     {
         /* Database properties react to createDB, not selectivity options. */
         if (strncmp(te->tag, "DATABASE ", 9) == 0)
         {
             if (!ropt->createDB)
                 return 0;
         }
         else if (ropt->schemaNames.head != NULL ||
                  ropt->schemaExcludeNames.head != NULL ||
                  ropt->selTypes)
         {
             /*
              * In a selective dump/restore, we want to restore these dependent
              * TOC entry types only if their parent object is being restored.
              * Without selectivity options, we let through everything in the
              * archive.  Note there may be such entries with no parent, eg
              * non-default ACLs for built-in objects.
              *
              * This code depends on the parent having been marked already,
              * which should be the case; if it isn't, perhaps due to
              * SortTocFromFile rearrangement, skipping the dependent entry
              * seems prudent anyway.
              *
              * Ideally we'd handle, eg, table CHECK constraints this way too.
              * But it's hard to tell which of their dependencies is the one to
              * consult.
              */
             if (te->nDeps != 1 ||
                 TocIDRequired(AH, te->dependencies[0]) == 0)
                 return 0;
         }
     }
     else
     {
         /* Apply selective-restore rules for standalone TOC entries. */
         if (ropt->schemaNames.head != NULL)
         {
             /* If no namespace is specified, it means all. */
             if (!te->namespace)
                 return 0;
             if (!simple_string_list_member(&ropt->schemaNames, te->namespace))
                 return 0;
         }
 
         if (ropt->schemaExcludeNames.head != NULL &&
             te->namespace &&
             simple_string_list_member(&ropt->schemaExcludeNames, te->namespace))
             return 0;
 
         if (ropt->selTypes)
         {
             if (strcmp(te->desc, "TABLE") == 0 ||
                 strcmp(te->desc, "TABLE DATA") == 0 ||
                 strcmp(te->desc, "VIEW") == 0 ||
                 strcmp(te->desc, "FOREIGN TABLE") == 0 ||
                 strcmp(te->desc, "MATERIALIZED VIEW") == 0 ||
                 strcmp(te->desc, "MATERIALIZED VIEW DATA") == 0 ||
                 strcmp(te->desc, "SEQUENCE") == 0 ||
                 strcmp(te->desc, "SEQUENCE SET") == 0)
             {
                 if (!ropt->selTable)
                     return 0;
                 if (ropt->tableNames.head != NULL &&
                     !simple_string_list_member(&ropt->tableNames, te->tag))
                     return 0;
             }
             else if (strcmp(te->desc, "INDEX") == 0)
             {
                 if (!ropt->selIndex)
                     return 0;
                 if (ropt->indexNames.head != NULL &&
                     !simple_string_list_member(&ropt->indexNames, te->tag))
                     return 0;
             }
             else if (strcmp(te->desc, "FUNCTION") == 0 ||
                      strcmp(te->desc, "AGGREGATE") == 0 ||
                      strcmp(te->desc, "PROCEDURE") == 0)
             {
                 if (!ropt->selFunction)
                     return 0;
                 if (ropt->functionNames.head != NULL &&
                     !simple_string_list_member(&ropt->functionNames, te->tag))
                     return 0;
             }
             else if (strcmp(te->desc, "TRIGGER") == 0)
             {
                 if (!ropt->selTrigger)
                     return 0;
                 if (ropt->triggerNames.head != NULL &&
                     !simple_string_list_member(&ropt->triggerNames, te->tag))
                     return 0;
             }
             else
                 return 0;
         }
     }
 
     /*
      * Determine whether the TOC entry contains schema and/or data components,
      * and mask off inapplicable REQ bits.  If it had a dataDumper, assume
      * it's both schema and data.  Otherwise it's probably schema-only, but
      * there are exceptions.
      */
     if (!te->hadDumper)
     {
         /*
          * Special Case: If 'SEQUENCE SET' or anything to do with BLOBs, then
          * it is considered a data entry.  We don't need to check for the
          * BLOBS entry or old-style BLOB COMMENTS, because they will have
          * hadDumper = true ... but we do need to check new-style BLOB ACLs,
          * comments, etc.
          */
         if (strcmp(te->desc, "SEQUENCE SET") == 0 ||
             strcmp(te->desc, "BLOB") == 0 ||
             (strcmp(te->desc, "ACL") == 0 &&
              strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
             (strcmp(te->desc, "COMMENT") == 0 &&
              strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
             (strcmp(te->desc, "SECURITY LABEL") == 0 &&
              strncmp(te->tag, "LARGE OBJECT ", 13) == 0))
             res = res & REQ_DATA;
         else
             res = res & ~REQ_DATA;
     }
 
     /* If there's no definition command, there's no schema component */
     if (!te->defn || !te->defn[0])
         res = res & ~REQ_SCHEMA;
 
     /*
      * Special case: <Init> type with <Max OID> tag; this is obsolete and we
      * always ignore it.
      */
     if ((strcmp(te->desc, "<Init>") == 0) && (strcmp(te->tag, "Max OID") == 0))
         return 0;
 
     /* Mask it if we only want schema */
     if (ropt->schemaOnly)
     {
         /*
          * The sequence_data option overrides schemaOnly for SEQUENCE SET.
          *
          * In binary-upgrade mode, even with schemaOnly set, we do not mask
          * out large objects.  (Only large object definitions, comments and
          * other metadata should be generated in binary-upgrade mode, not the
          * actual data, but that need not concern us here.)
          */
         if (!(ropt->sequence_data && strcmp(te->desc, "SEQUENCE SET") == 0) &&
             !(ropt->binary_upgrade &&
               (strcmp(te->desc, "BLOB") == 0 ||
                (strcmp(te->desc, "ACL") == 0 &&
                 strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
                (strcmp(te->desc, "COMMENT") == 0 &&
                 strncmp(te->tag, "LARGE OBJECT ", 13) == 0) ||
                (strcmp(te->desc, "SECURITY LABEL") == 0 &&
                 strncmp(te->tag, "LARGE OBJECT ", 13) == 0))))
             res = res & REQ_SCHEMA;
     }
 
     /* Mask it if we only want data */
     if (ropt->dataOnly)
         res = res & REQ_DATA;
 
     return res;
 }

◆ _tocEntryRestorePass()

static RestorePass _tocEntryRestorePass ( TocEntry * te )

static

Definition at line 3078 of file pg_backup_archiver.c.

References _tocEntry::desc, RESTORE_PASS_ACL, and RESTORE_PASS_MAIN.

Referenced by move_to_ready_list(), reduce_dependencies(), restore_toc_entries_prefork(), and RestoreArchive().

 {
     /* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */
     if (strcmp(te->desc, "ACL") == 0 ||
         strcmp(te->desc, "ACL LANGUAGE") == 0 ||
         strcmp(te->desc, "DEFAULT ACL") == 0)
         return RESTORE_PASS_ACL;
     if (strcmp(te->desc, "EVENT TRIGGER") == 0 ||
         strcmp(te->desc, "MATERIALIZED VIEW DATA") == 0)
         return RESTORE_PASS_POST_ACL;
     return RESTORE_PASS_MAIN;
 }

◆ ahprintf()

int ahprintf	(	ArchiveHandle *	AH,
		const char *	fmt,
			...
	)

Definition at line 1603 of file pg_backup_archiver.c.

References ahwrite(), generate_unaccent_rules::args, free, pg_malloc(), and pvsnprintf().

Referenced by _disableTriggersIfNecessary(), _doSetFixedOutputState(), _doSetSessionAuth(), _enableTriggersIfNecessary(), _EndBlob(), _EndBlobs(), _EndData(), _PrintExtraToc(), _PrintTocData(), _printTocEntry(), _reconnectToDB(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), _StartBlob(), _StartBlobs(), _WriteBlobData(), DropBlobIfExists(), dump_lo_buf(), dumpTimestamp(), EndRestoreBlob(), EndRestoreBlobs(), PrintTOCSummary(), restore_toc_entry(), RestoreArchive(), StartRestoreBlob(), and StartRestoreBlobs().

 {
     int         save_errno = errno;
     char       *p;
     size_t      len = 128;      /* initial assumption about buffer size */
     size_t      cnt;
 
     for (;;)
     {
         va_list     args;
 
         /* Allocate work buffer. */
         p = (char *) pg_malloc(len);
 
         /* Try to format the data. */
         errno = save_errno;
         va_start(args, fmt);
         cnt = pvsnprintf(p, len, fmt, args);
         va_end(args);
 
         if (cnt < len)
             break;              /* success */
 
         /* Release buffer and loop around to try again with larger len. */
         free(p);
         len = cnt;
     }
 
     ahwrite(p, 1, cnt, AH);
     free(p);
     return (int) cnt;
 }

◆ ahwrite()

void ahwrite	(	const void *	ptr,
		size_t	size,
		size_t	nmemb,
		ArchiveHandle *	AH
	)

Definition at line 1693 of file pg_backup_archiver.c.

References _archiveHandle::CustomOutPtr, dump_lo_buf(), ExecuteSqlCommandBuf(), _archiveHandle::gzOut, GZWRITE, _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, _archiveHandle::lo_buf_used, _archiveHandle::OF, _archiveHandle::public, remaining, RestoringToDB(), WRITE_ERROR_EXIT, and _archiveHandle::writingBlob.

Referenced by _LoadBlobs(), _PrintFileData(), _PrintTocData(), _WriteData(), ahprintf(), EndCompressor(), and ReadDataFromArchiveNone().

 {
     int         bytes_written = 0;
 
     if (AH->writingBlob)
     {
         size_t      remaining = size * nmemb;
 
         while (AH->lo_buf_used + remaining > AH->lo_buf_size)
         {
             size_t      avail = AH->lo_buf_size - AH->lo_buf_used;
 
             memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
             ptr = (const void *) ((const char *) ptr + avail);
             remaining -= avail;
             AH->lo_buf_used += avail;
             dump_lo_buf(AH);
         }
 
         memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
         AH->lo_buf_used += remaining;
 
         bytes_written = size * nmemb;
     }
     else if (AH->gzOut)
         bytes_written = GZWRITE(ptr, size, nmemb, AH->OF);
     else if (AH->CustomOutPtr)
         bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
 
     else
     {
         /*
          * If we're doing a restore, and it's direct to DB, and we're
          * connected then send it to the DB.
          */
         if (RestoringToDB(AH))
             bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
         else
             bytes_written = fwrite(ptr, size, nmemb, AH->OF) * size;
     }
 
     if (bytes_written != size * nmemb)
         WRITE_ERROR_EXIT;
 }

◆ ArchiveEntry()

TocEntry* ArchiveEntry	(	Archive *	AHX,
		CatalogId	catalogId,
		DumpId	dumpId,
		ArchiveOpts *	opts
	)

Definition at line 1061 of file pg_backup_archiver.c.

References _archiveHandle::ArchiveEntryPtr, _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, _tocEntry::formatData, _tocEntry::hadDumper, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, _tocEntry::owner, pg_malloc(), pg_malloc0(), pg_strdup(), _tocEntry::prev, _tocEntry::section, _tocEntry::tableam, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and true.

Referenced by dumpAccessMethod(), dumpACL(), dumpAgg(), dumpAttrDef(), dumpBaseType(), dumpBlob(), dumpCast(), dumpCollation(), dumpComment(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

 {
     ArchiveHandle *AH = (ArchiveHandle *) AHX;
     TocEntry   *newToc;
 
     newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
     AH->tocCount++;
     if (dumpId > AH->maxDumpId)
         AH->maxDumpId = dumpId;
 
     newToc->prev = AH->toc->prev;
     newToc->next = AH->toc;
     AH->toc->prev->next = newToc;
     AH->toc->prev = newToc;
 
     newToc->catalogId = catalogId;
     newToc->dumpId = dumpId;
     newToc->section = opts->section;
 
     newToc->tag = pg_strdup(opts->tag);
     newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
     newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
     newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
     newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
     newToc->desc = pg_strdup(opts->description);
     newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
     newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
     newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
 
     if (opts->nDeps > 0)
     {
         newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
         memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
         newToc->nDeps = opts->nDeps;
     }
     else
     {
         newToc->dependencies = NULL;
         newToc->nDeps = 0;
     }
 
     newToc->dataDumper = opts->dumpFn;
     newToc->dataDumperArg = opts->dumpArg;
     newToc->hadDumper = opts->dumpFn ? true : false;
 
     newToc->formatData = NULL;
     newToc->dataLength = 0;
 
     if (AH->ArchiveEntryPtr != NULL)
         AH->ArchiveEntryPtr(AH, newToc);
 
     return newToc;
 }

◆ archprintf()

int archprintf	(	Archive *	AH,
		const char *	fmt,
			...
	)

Definition at line 1466 of file pg_backup_archiver.c.

References generate_unaccent_rules::args, free, pg_malloc(), pvsnprintf(), and WriteData().

 {
     int         save_errno = errno;
     char       *p;
     size_t      len = 128;      /* initial assumption about buffer size */
     size_t      cnt;
 
     for (;;)
     {
         va_list     args;
 
         /* Allocate work buffer. */
         p = (char *) pg_malloc(len);
 
         /* Try to format the data. */
         errno = save_errno;
         va_start(args, fmt);
         cnt = pvsnprintf(p, len, fmt, args);
         va_end(args);
 
         if (cnt < len)
             break;              /* success */
 
         /* Release buffer and loop around to try again with larger len. */
         free(p);
         len = cnt;
     }
 
     WriteData(AH, p, cnt);
     free(p);
     return (int) cnt;
 }

◆ archputs()

void archputs	(	const char *	s,
		Archive *	AH
	)

Definition at line 1459 of file pg_backup_archiver.c.

References WriteData().

Referenced by dumpTableData_insert().

 {
     WriteData(AH, s, strlen(s));
 }

◆ buildTocEntryArrays()

static void buildTocEntryArrays ( ArchiveHandle * AH )

static

Definition at line 1832 of file pg_backup_archiver.c.

References _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dumpId, fatal, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, pg_malloc0(), _archiveHandle::tableDataId, _archiveHandle::toc, and _archiveHandle::tocsByDumpId.

Referenced by getTocEntryByDumpId(), and RestoreArchive().

 {
     DumpId      maxDumpId = AH->maxDumpId;
     TocEntry   *te;
 
     AH->tocsByDumpId = (TocEntry **) pg_malloc0((maxDumpId + 1) * sizeof(TocEntry *));
     AH->tableDataId = (DumpId *) pg_malloc0((maxDumpId + 1) * sizeof(DumpId));
 
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         /* this check is purely paranoia, maxDumpId should be correct */
         if (te->dumpId <= 0 || te->dumpId > maxDumpId)
             fatal("bad dumpId");
 
         /* tocsByDumpId indexes all TOCs by their dump ID */
         AH->tocsByDumpId[te->dumpId] = te;
 
         /*
          * tableDataId provides the TABLE DATA item's dump ID for each TABLE
          * TOC entry that has a DATA item.  We compute this by reversing the
          * TABLE DATA item's dependency, knowing that a TABLE DATA item has
          * just one dependency and it is the TABLE item.
          */
         if (strcmp(te->desc, "TABLE DATA") == 0 && te->nDeps > 0)
         {
             DumpId      tableId = te->dependencies[0];
 
             /*
              * The TABLE item might not have been in the archive, if this was
              * a data-only dump; but its dump ID should be less than its data
              * item's dump ID, so there should be a place for it in the array.
              */
             if (tableId <= 0 || tableId > maxDumpId)
                 fatal("bad table dumpId for TABLE DATA item");
 
             AH->tableDataId[tableId] = te->dumpId;
         }
     }
 }

◆ checkSeek()

bool checkSeek ( FILE * fp )

Definition at line 3872 of file pg_backup_archiver.c.

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

 {
     pgoff_t     tpos;
 
     /* Check that ftello works on this file */
     tpos = ftello(fp);
     if (tpos < 0)
         return false;
 
     /*
      * Check that fseeko(SEEK_SET) works, too.  NB: we used to try to test
      * this with fseeko(fp, 0, SEEK_CUR).  But some platforms treat that as a
      * successful no-op even on files that are otherwise unseekable.
      */
     if (fseeko(fp, tpos, SEEK_SET) != 0)
         return false;
 
     return true;
 }

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle * AH )

Definition at line 4798 of file pg_backup_archiver.c.

References _doSetFixedOutputState(), appendConnStrVal(), appendPQExpBufferStr(), archModeRead, Assert, _archiveHandle::ClonePtr, _archiveHandle::connCancel, ConnectDatabase(), _archiveHandle::connection, connstr, _archiveHandle::currSchema, _archiveHandle::currTablespace, _archiveHandle::currUser, PQExpBufferData::data, _restoreOptions::dbname, initPQExpBuffer(), _archiveHandle::mode, Archive::n_errors, pg_malloc(), pg_strdup(), _restoreOptions::pghost, pghost, _restoreOptions::pgport, pgport, PQdb(), PQhost(), PQport(), PQuser(), _restoreOptions::promptPassword, _archiveHandle::public, Archive::ropt, _archiveHandle::savedPassword, _archiveHandle::sqlparse, termPQExpBuffer(), TRI_NO, _restoreOptions::username, and username.

Referenced by RunWorker().

 {
     ArchiveHandle *clone;
 
     /* Make a "flat" copy */
     clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
     memcpy(clone, AH, sizeof(ArchiveHandle));
 
     /* Handle format-independent fields */
     memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
 
     /* The clone will have its own connection, so disregard connection state */
     clone->connection = NULL;
     clone->connCancel = NULL;
     clone->currUser = NULL;
     clone->currSchema = NULL;
     clone->currTablespace = NULL;
 
     /* savedPassword must be local in case we change it while connecting */
     if (clone->savedPassword)
         clone->savedPassword = pg_strdup(clone->savedPassword);
 
     /* clone has its own error count, too */
     clone->public.n_errors = 0;
 
     /*
      * Connect our new clone object to the database: In parallel restore the
      * parent is already disconnected, because we can connect the worker
      * processes independently to the database (no snapshot sync required). In
      * parallel backup we clone the parent's existing connection.
      */
     if (AH->mode == archModeRead)
     {
         RestoreOptions *ropt = AH->public.ropt;
 
         Assert(AH->connection == NULL);
 
         /* this also sets clone->connection */
         ConnectDatabase((Archive *) clone, ropt->dbname,
                         ropt->pghost, ropt->pgport, ropt->username,
                         ropt->promptPassword);
 
         /* re-establish fixed state */
         _doSetFixedOutputState(clone);
     }
     else
     {
         PQExpBufferData connstr;
         char       *pghost;
         char       *pgport;
         char       *username;
 
         Assert(AH->connection != NULL);
 
         /*
          * Even though we are technically accessing the parent's database
          * object here, these functions are fine to be called like that
          * because all just return a pointer and do not actually send/receive
          * any data to/from the database.
          */
         initPQExpBuffer(&connstr);
         appendPQExpBufferStr(&connstr, "dbname=");
         appendConnStrVal(&connstr, PQdb(AH->connection));
         pghost = PQhost(AH->connection);
         pgport = PQport(AH->connection);
         username = PQuser(AH->connection);
 
         /* this also sets clone->connection */
         ConnectDatabase((Archive *) clone, connstr.data,
                         pghost, pgport, username, TRI_NO);
 
         termPQExpBuffer(&connstr);
         /* setupDumpWorker will fix up connection state */
     }
 
     /* Let the format-specific code have a chance too */
     clone->ClonePtr(clone);
 
     Assert(clone->connection != NULL);
     return clone;
 }

◆ CloseArchive()

void CloseArchive ( Archive * AHX )

Definition at line 257 of file pg_backup_archiver.c.

References _archiveHandle::ClosePtr, fatal, GZCLOSE, _archiveHandle::gzOut, _archiveHandle::OF, and generate_unaccent_rules::stdout.

Referenced by main().

 {
     int         res = 0;
     ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
     AH->ClosePtr(AH);
 
     /* Close the output */
     if (AH->gzOut)
         res = GZCLOSE(AH->OF);
     else if (AH->OF != stdout)
         res = fclose(AH->OF);
 
     if (res != 0)
         fatal("could not close output file: %m");
 }

◆ CreateArchive()

Archive* CreateArchive	(	const char *	FileSpec,
		const ArchiveFormat	fmt,
		const int	compression,
		bool	dosync,
		ArchiveMode	mode,
		SetupWorkerPtrType	setupDumpWorker
	)

Definition at line 234 of file pg_backup_archiver.c.

References _allocAH().

Referenced by main().

 {
     ArchiveHandle *AH = _allocAH(FileSpec, fmt, compression, dosync,
                                  mode, setupDumpWorker);
 
     return (Archive *) AH;
 }

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle * AH )

Definition at line 4886 of file pg_backup_archiver.c.

References Assert, _archiveHandle::connection, sqlparseInfo::curCmd, _archiveHandle::currSchema, _archiveHandle::currTableAm, _archiveHandle::currTablespace, _archiveHandle::currUser, _archiveHandle::DeClonePtr, destroyPQExpBuffer(), free, _archiveHandle::savedPassword, and _archiveHandle::sqlparse.

Referenced by RunWorker().

 {
     /* Should not have an open database connection */
     Assert(AH->connection == NULL);
 
     /* Clear format-specific state */
     AH->DeClonePtr(AH);
 
     /* Clear state allocated by CloneArchive */
     if (AH->sqlparse.curCmd)
         destroyPQExpBuffer(AH->sqlparse.curCmd);
 
     /* Clear any connection-local state */
     if (AH->currUser)
         free(AH->currUser);
     if (AH->currSchema)
         free(AH->currSchema);
     if (AH->currTablespace)
         free(AH->currTablespace);
     if (AH->currTableAm)
         free(AH->currTableAm);
     if (AH->savedPassword)
         free(AH->savedPassword);
 
     free(AH);
 }

◆ dump_lo_buf()

static void dump_lo_buf ( ArchiveHandle * AH )

static

Definition at line 1651 of file pg_backup_archiver.c.

References ahprintf(), appendByteaLiteralAHX, buf, _archiveHandle::connection, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), fatal, _archiveHandle::lo_buf, _archiveHandle::lo_buf_used, lo_write(), _archiveHandle::loFd, ngettext, pg_log_debug, and _archiveHandle::writingBlob.

Referenced by ahwrite(), and EndRestoreBlob().

 {
     if (AH->connection)
     {
         size_t      res;
 
         res = lo_write(AH->connection, AH->loFd, AH->lo_buf, AH->lo_buf_used);
         pg_log_debug(ngettext("wrote %lu byte of large object data (result = %lu)",
                               "wrote %lu bytes of large object data (result = %lu)",
                               AH->lo_buf_used),
                      (unsigned long) AH->lo_buf_used, (unsigned long) res);
         if (res != AH->lo_buf_used)
             fatal("could not write to large object (result: %lu, expected: %lu)",
                   (unsigned long) res, (unsigned long) AH->lo_buf_used);
     }
     else
     {
         PQExpBuffer buf = createPQExpBuffer();
 
         appendByteaLiteralAHX(buf,
                               (const unsigned char *) AH->lo_buf,
                               AH->lo_buf_used,
                               AH);
 
         /* Hack: turn off writingBlob so ahwrite doesn't recurse to here */
         AH->writingBlob = 0;
         ahprintf(AH, "SELECT pg_catalog.lowrite(0, %s);\n", buf->data);
         AH->writingBlob = 1;
 
         destroyPQExpBuffer(buf);
     }
     AH->lo_buf_used = 0;
 }

◆ dumpOptionsFromRestoreOptions()

DumpOptions* dumpOptionsFromRestoreOptions ( RestoreOptions * ropt )

Definition at line 176 of file pg_backup_archiver.c.

References _restoreOptions::aclsSkip, _dumpOptions::aclsSkip, _restoreOptions::column_inserts, _dumpOptions::column_inserts, _restoreOptions::createDB, _restoreOptions::dataOnly, _dumpOptions::dataOnly, _restoreOptions::disable_dollar_quoting, _dumpOptions::disable_dollar_quoting, _restoreOptions::disable_triggers, _dumpOptions::disable_triggers, _restoreOptions::dropSchema, _restoreOptions::dump_inserts, _dumpOptions::dump_inserts, _restoreOptions::dumpSections, _dumpOptions::dumpSections, _restoreOptions::enable_row_security, _dumpOptions::enable_row_security, _restoreOptions::if_exists, _dumpOptions::if_exists, _restoreOptions::include_everything, _dumpOptions::include_everything, _restoreOptions::lockWaitTimeout, _dumpOptions::lockWaitTimeout, NewDumpOptions(), _restoreOptions::no_comments, _dumpOptions::no_comments, _restoreOptions::no_publications, _dumpOptions::no_publications, _restoreOptions::no_security_labels, _dumpOptions::no_security_labels, _restoreOptions::no_subscriptions, _dumpOptions::no_subscriptions, _restoreOptions::noOwner, _restoreOptions::noTablespace, _dumpOptions::outputClean, _dumpOptions::outputCreateDB, _dumpOptions::outputNoOwner, _dumpOptions::outputNoTablespaces, _dumpOptions::outputSuperuser, _restoreOptions::schemaOnly, _dumpOptions::schemaOnly, _restoreOptions::sequence_data, _dumpOptions::sequence_data, _restoreOptions::superuser, _restoreOptions::use_setsessauth, and _dumpOptions::use_setsessauth.

Referenced by SetArchiveOptions().

 {
     DumpOptions *dopt = NewDumpOptions();
 
     /* this is the inverse of what's at the end of pg_dump.c's main() */
     dopt->outputClean = ropt->dropSchema;
     dopt->dataOnly = ropt->dataOnly;
     dopt->schemaOnly = ropt->schemaOnly;
     dopt->if_exists = ropt->if_exists;
     dopt->column_inserts = ropt->column_inserts;
     dopt->dumpSections = ropt->dumpSections;
     dopt->aclsSkip = ropt->aclsSkip;
     dopt->outputSuperuser = ropt->superuser;
     dopt->outputCreateDB = ropt->createDB;
     dopt->outputNoOwner = ropt->noOwner;
     dopt->outputNoTablespaces = ropt->noTablespace;
     dopt->disable_triggers = ropt->disable_triggers;
     dopt->use_setsessauth = ropt->use_setsessauth;
     dopt->disable_dollar_quoting = ropt->disable_dollar_quoting;
     dopt->dump_inserts = ropt->dump_inserts;
     dopt->no_comments = ropt->no_comments;
     dopt->no_publications = ropt->no_publications;
     dopt->no_security_labels = ropt->no_security_labels;
     dopt->no_subscriptions = ropt->no_subscriptions;
     dopt->lockWaitTimeout = ropt->lockWaitTimeout;
     dopt->include_everything = ropt->include_everything;
     dopt->enable_row_security = ropt->enable_row_security;
     dopt->sequence_data = ropt->sequence_data;
 
     return dopt;
 }

◆ dumpTimestamp()

static void dumpTimestamp	(	ArchiveHandle *	AH,
		const char *	msg,
		time_t	tim
	)

static

Definition at line 3897 of file pg_backup_archiver.c.

References ahprintf(), buf, and PGDUMP_STRFTIME_FMT.

Referenced by RestoreArchive().

 {
     char        buf[64];
 
     if (strftime(buf, sizeof(buf), PGDUMP_STRFTIME_FMT, localtime(&tim)) != 0)
         ahprintf(AH, "-- %s %s\n\n", msg, buf);
 }

◆ EndBlob()

int EndBlob	(	Archive *	AHX,
		Oid	oid
	)

Definition at line 1237 of file pg_backup_archiver.c.

References _archiveHandle::currToc, and _archiveHandle::EndBlobPtr.

Referenced by dumpBlobs().

 {
     ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
     if (AH->EndBlobPtr)
         AH->EndBlobPtr(AH, AH->currToc, oid);
 
     return 1;
 }

◆ EndRestoreBlob()

void EndRestoreBlob	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 1341 of file pg_backup_archiver.c.

References ahprintf(), _archiveHandle::connection, dump_lo_buf(), _archiveHandle::lo_buf_used, lo_close(), _archiveHandle::loFd, and _archiveHandle::writingBlob.

Referenced by _LoadBlobs().

 {
     if (AH->lo_buf_used > 0)
     {
         /* Write remaining bytes from the LO buffer */
         dump_lo_buf(AH);
     }
 
     AH->writingBlob = 0;
 
     if (AH->connection)
     {
         lo_close(AH->connection, AH->loFd);
         AH->loFd = -1;
     }
     else
     {
         ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
     }
 }

◆ EndRestoreBlobs()

void EndRestoreBlobs ( ArchiveHandle * AH )

Definition at line 1274 of file pg_backup_archiver.c.

References ahprintf(), _archiveHandle::blobCount, CommitTransaction(), _archiveHandle::connection, ngettext, pg_log_info, _archiveHandle::public, Archive::ropt, and _restoreOptions::single_txn.

Referenced by _LoadBlobs().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     if (!ropt->single_txn)
     {
         if (AH->connection)
             CommitTransaction(&AH->public);
         else
             ahprintf(AH, "COMMIT;\n\n");
     }
 
     pg_log_info(ngettext("restored %d large object",
                          "restored %d large objects",
                          AH->blobCount),
                 AH->blobCount);
 }

◆ fix_dependencies()

static void fix_dependencies ( ArchiveHandle * AH )

static

Definition at line 4495 of file pg_backup_archiver.c.

References _tocEntry::depCount, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dumpId, i, identify_locking_dependencies(), K_VERS_1_11, _tocEntry::lockDeps, _tocEntry::nDeps, _tocEntry::next, _tocEntry::nLockDeps, _tocEntry::nRevDeps, _tocEntry::pending_next, _tocEntry::pending_prev, pg_malloc(), repoint_table_dependencies(), _tocEntry::revDeps, _archiveHandle::toc, _archiveHandle::tocsByDumpId, and _archiveHandle::version.

Referenced by IndexSetParentIndex(), and restore_toc_entries_prefork().

 {
     TocEntry   *te;
     int         i;
 
     /*
      * Initialize the depCount/revDeps/nRevDeps fields, and make sure the TOC
      * items are marked as not being in any parallel-processing list.
      */
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         te->depCount = te->nDeps;
         te->revDeps = NULL;
         te->nRevDeps = 0;
         te->pending_prev = NULL;
         te->pending_next = NULL;
     }
 
     /*
      * POST_DATA items that are shown as depending on a table need to be
      * re-pointed to depend on that table's data, instead.  This ensures they
      * won't get scheduled until the data has been loaded.
      */
     repoint_table_dependencies(AH);
 
     /*
      * Pre-8.4 versions of pg_dump neglected to set up a dependency from BLOB
      * COMMENTS to BLOBS.  Cope.  (We assume there's only one BLOBS and only
      * one BLOB COMMENTS in such files.)
      */
     if (AH->version < K_VERS_1_11)
     {
         for (te = AH->toc->next; te != AH->toc; te = te->next)
         {
             if (strcmp(te->desc, "BLOB COMMENTS") == 0 && te->nDeps == 0)
             {
                 TocEntry   *te2;
 
                 for (te2 = AH->toc->next; te2 != AH->toc; te2 = te2->next)
                 {
                     if (strcmp(te2->desc, "BLOBS") == 0)
                     {
                         te->dependencies = (DumpId *) pg_malloc(sizeof(DumpId));
                         te->dependencies[0] = te2->dumpId;
                         te->nDeps++;
                         te->depCount++;
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     /*
      * At this point we start to build the revDeps reverse-dependency arrays,
      * so all changes of dependencies must be complete.
      */
 
     /*
      * Count the incoming dependencies for each item.  Also, it is possible
      * that the dependencies list items that are not in the archive at all
      * (that should not happen in 9.2 and later, but is highly likely in older
      * archives).  Subtract such items from the depCounts.
      */
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         for (i = 0; i < te->nDeps; i++)
         {
             DumpId      depid = te->dependencies[i];
 
             if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL)
                 AH->tocsByDumpId[depid]->nRevDeps++;
             else
                 te->depCount--;
         }
     }
 
     /*
      * Allocate space for revDeps[] arrays, and reset nRevDeps so we can use
      * it as a counter below.
      */
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         if (te->nRevDeps > 0)
             te->revDeps = (DumpId *) pg_malloc(te->nRevDeps * sizeof(DumpId));
         te->nRevDeps = 0;
     }
 
     /*
      * Build the revDeps[] arrays of incoming-dependency dumpIds.  This had
      * better agree with the loops above.
      */
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         for (i = 0; i < te->nDeps; i++)
         {
             DumpId      depid = te->dependencies[i];
 
             if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL)
             {
                 TocEntry   *otherte = AH->tocsByDumpId[depid];
 
                 otherte->revDeps[otherte->nRevDeps++] = te->dumpId;
             }
         }
     }
 
     /*
      * Lastly, work out the locking dependencies.
      */
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         te->lockDeps = NULL;
         te->nLockDeps = 0;
         identify_locking_dependencies(AH, te);
     }
 }

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1873 of file pg_backup_archiver.c.

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

Referenced by parseWorkerCommand(), SortTocFromFile(), and TocIDRequired().

 {
     /* build index arrays if we didn't already */
     if (AH->tocsByDumpId == NULL)
         buildTocEntryArrays(AH);
 
     if (id > 0 && id <= AH->maxDumpId)
         return AH->tocsByDumpId[id];
 
     return NULL;
 }

◆ has_lock_conflicts()

static bool has_lock_conflicts	(	TocEntry *	te1,
		TocEntry *	te2
	)

static

Definition at line 4186 of file pg_backup_archiver.c.

References _tocEntry::dependencies, _tocEntry::lockDeps, _tocEntry::nDeps, and _tocEntry::nLockDeps.

Referenced by pop_next_work_item().

 {
     int         j,
                 k;
 
     for (j = 0; j < te1->nLockDeps; j++)
     {
         for (k = 0; k < te2->nDeps; k++)
         {
             if (te1->lockDeps[j] == te2->dependencies[k])
                 return true;
         }
     }
     return false;
 }

◆ identify_locking_dependencies()

static void identify_locking_dependencies	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 4659 of file pg_backup_archiver.c.

References _tocEntry::dependencies, _tocEntry::desc, free, i, _tocEntry::lockDeps, _tocEntry::nDeps, _tocEntry::nLockDeps, pg_malloc(), pg_realloc(), _tocEntry::section, SECTION_POST_DATA, and _archiveHandle::tocsByDumpId.

Referenced by fix_dependencies().

 {
     DumpId     *lockids;
     int         nlockids;
     int         i;
 
     /*
      * We only care about this for POST_DATA items.  PRE_DATA items are not
      * run in parallel, and DATA items are all independent by assumption.
      */
     if (te->section != SECTION_POST_DATA)
         return;
 
     /* Quick exit if no dependencies at all */
     if (te->nDeps == 0)
         return;
 
     /*
      * Most POST_DATA items are ALTER TABLEs or some moral equivalent of that,
      * and hence require exclusive lock.  However, we know that CREATE INDEX
      * does not.  (Maybe someday index-creating CONSTRAINTs will fall in that
      * category too ... but today is not that day.)
      */
     if (strcmp(te->desc, "INDEX") == 0)
         return;
 
     /*
      * We assume the entry requires exclusive lock on each TABLE or TABLE DATA
      * item listed among its dependencies.  Originally all of these would have
      * been TABLE items, but repoint_table_dependencies would have repointed
      * them to the TABLE DATA items if those are present (which they might not
      * be, eg in a schema-only dump).  Note that all of the entries we are
      * processing here are POST_DATA; otherwise there might be a significant
      * difference between a dependency on a table and a dependency on its
      * data, so that closer analysis would be needed here.
      */
     lockids = (DumpId *) pg_malloc(te->nDeps * sizeof(DumpId));
     nlockids = 0;
     for (i = 0; i < te->nDeps; i++)
     {
         DumpId      depid = te->dependencies[i];
 
         if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL &&
             ((strcmp(AH->tocsByDumpId[depid]->desc, "TABLE DATA") == 0) ||
              strcmp(AH->tocsByDumpId[depid]->desc, "TABLE") == 0))
             lockids[nlockids++] = depid;
     }
 
     if (nlockids == 0)
     {
         free(lockids);
         return;
     }
 
     te->lockDeps = pg_realloc(lockids, nlockids * sizeof(DumpId));
     te->nLockDeps = nlockids;
 }

◆ inhibit_data_for_failed_table()

static void inhibit_data_for_failed_table	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 4778 of file pg_backup_archiver.c.

References _tocEntry::dumpId, pg_log_info, _tocEntry::reqs, _archiveHandle::tableDataId, _tocEntry::tag, and _archiveHandle::tocsByDumpId.

Referenced by mark_restore_job_done(), and restore_toc_entry().

 {
     pg_log_info("table \"%s\" could not be created, will not restore its data",
                 te->tag);
 
     if (AH->tableDataId[te->dumpId] != 0)
     {
         TocEntry   *ted = AH->tocsByDumpId[AH->tableDataId[te->dumpId]];
 
         ted->reqs = 0;
     }
 }

◆ InitDumpOptions()

void InitDumpOptions ( DumpOptions * opts )

Definition at line 163 of file pg_backup_archiver.c.

References DUMP_UNSECTIONED, _dumpOptions::dumpSections, and _dumpOptions::include_everything.

Referenced by main(), and NewDumpOptions().

 {
     memset(opts, 0, sizeof(DumpOptions));
     /* set any fields that shouldn't default to zeroes */
     opts->include_everything = true;
     opts->dumpSections = DUMP_UNSECTIONED;
 }

◆ mark_create_done()

static void mark_create_done	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 4763 of file pg_backup_archiver.c.

References _tocEntry::created, _tocEntry::dumpId, _archiveHandle::tableDataId, and _archiveHandle::tocsByDumpId.

Referenced by mark_restore_job_done(), and restore_toc_entry().

 {
     if (AH->tableDataId[te->dumpId] != 0)
     {
         TocEntry   *ted = AH->tocsByDumpId[AH->tableDataId[te->dumpId]];
 
         ted->created = true;
     }
 }

◆ mark_dump_job_done()

static void mark_dump_job_done	(	ArchiveHandle *	AH,
		TocEntry *	te,
		int	status,
		void *	callback_data
	)

static

Definition at line 2456 of file pg_backup_archiver.c.

References _tocEntry::desc, _tocEntry::dumpId, fatal, pg_log_info, and _tocEntry::tag.

Referenced by WriteDataChunks().

 {
     pg_log_info("finished item %d %s %s",
                 te->dumpId, te->desc, te->tag);
 
     if (status != 0)
         fatal("worker process failed: exit code %d",
               status);
 }

◆ mark_restore_job_done()

static void mark_restore_job_done	(	ArchiveHandle *	AH,
		TocEntry *	te,
		int	status,
		void *	callback_data
	)

static

Definition at line 4454 of file pg_backup_archiver.c.

References _tocEntry::desc, _tocEntry::dumpId, fatal, inhibit_data_for_failed_table(), mark_create_done(), Archive::n_errors, pg_log_info, _archiveHandle::public, reduce_dependencies(), _tocEntry::tag, WORKER_CREATE_DONE, WORKER_IGNORED_ERRORS, and WORKER_INHIBIT_DATA.

Referenced by restore_toc_entries_parallel().

 {
     ParallelReadyList *ready_list = (ParallelReadyList *) callback_data;
 
     pg_log_info("finished item %d %s %s",
                 te->dumpId, te->desc, te->tag);
 
     if (status == WORKER_CREATE_DONE)
         mark_create_done(AH, te);
     else if (status == WORKER_INHIBIT_DATA)
     {
         inhibit_data_for_failed_table(AH, te);
         AH->public.n_errors++;
     }
     else if (status == WORKER_IGNORED_ERRORS)
         AH->public.n_errors++;
     else if (status != 0)
         fatal("worker process failed: exit code %d",
               status);
 
     reduce_dependencies(AH, te, ready_list);
 }

◆ move_to_ready_list()

static void move_to_ready_list	(	TocEntry *	pending_list,
		ParallelReadyList *	ready_list,
		RestorePass	pass
	)

static

Definition at line 4339 of file pg_backup_archiver.c.

References _tocEntryRestorePass(), _tocEntry::depCount, pending_list_remove(), _tocEntry::pending_next, and ready_list_insert().

Referenced by restore_toc_entries_parallel().

 {
     TocEntry   *te;
     TocEntry   *next_te;
 
     for (te = pending_list->pending_next; te != pending_list; te = next_te)
     {
         /* must save list link before possibly removing te from list */
         next_te = te->pending_next;
 
         if (te->depCount == 0 &&
             _tocEntryRestorePass(te) == pass)
         {
             /* Remove it from pending_list ... */
             pending_list_remove(te);
             /* ... and add to ready_list */
             ready_list_insert(ready_list, te);
         }
     }
 }

◆ NewDumpOptions()

DumpOptions* NewDumpOptions ( void )

Definition at line 151 of file pg_backup_archiver.c.

References InitDumpOptions(), and pg_malloc().

Referenced by dumpOptionsFromRestoreOptions().

 {
     DumpOptions *opts = (DumpOptions *) pg_malloc(sizeof(DumpOptions));
 
     InitDumpOptions(opts);
     return opts;
 }

◆ NewRestoreOptions()

RestoreOptions* NewRestoreOptions ( void )

Definition at line 968 of file pg_backup_archiver.c.

References archUnknown, DUMP_UNSECTIONED, _restoreOptions::dumpSections, _restoreOptions::format, pg_malloc0(), _restoreOptions::promptPassword, and TRI_DEFAULT.

Referenced by _CloseArchive(), and main().

 {
     RestoreOptions *opts;
 
     opts = (RestoreOptions *) pg_malloc0(sizeof(RestoreOptions));
 
     /* set any fields that shouldn't default to zeroes */
     opts->format = archUnknown;
     opts->promptPassword = TRI_DEFAULT;
     opts->dumpSections = DUMP_UNSECTIONED;
 
     return opts;
 }

◆ OpenArchive()

Archive* OpenArchive	(	const char *	FileSpec,
		const ArchiveFormat	fmt
	)

Definition at line 248 of file pg_backup_archiver.c.

References _allocAH(), archModeRead, and setupRestoreWorker().

Referenced by main().

 {
     ArchiveHandle *AH = _allocAH(FileSpec, fmt, 0, true, archModeRead, setupRestoreWorker);
 
     return (Archive *) AH;
 }

◆ parallel_restore()

int parallel_restore	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 4431 of file pg_backup_archiver.c.

References Assert, _archiveHandle::connection, Archive::n_errors, _archiveHandle::public, restore_toc_entry(), and status().

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

 {
     int         status;
 
     Assert(AH->connection != NULL);
 
     /* Count only errors associated with this TOC entry */
     AH->public.n_errors = 0;
 
     /* Restore the TOC item */
     status = restore_toc_entry(AH, te, true);
 
     return status;
 }

◆ pending_list_append()

static void pending_list_append	(	TocEntry *	l,
		TocEntry *	te
	)

static

Definition at line 4218 of file pg_backup_archiver.c.

References _tocEntry::pending_next, and _tocEntry::pending_prev.

Referenced by restore_toc_entries_prefork().

 {
     te->pending_prev = l->pending_prev;
     l->pending_prev->pending_next = te;
     l->pending_prev = te;
     te->pending_next = l;
 }

◆ pending_list_header_init()

static void pending_list_header_init ( TocEntry * l )

static

Definition at line 4211 of file pg_backup_archiver.c.

References _tocEntry::pending_next, and _tocEntry::pending_prev.

Referenced by RestoreArchive().

 {
     l->pending_prev = l->pending_next = l;
 }

◆ pending_list_remove()

static void pending_list_remove ( TocEntry * te )

static

Definition at line 4228 of file pg_backup_archiver.c.

References _tocEntry::pending_next, and _tocEntry::pending_prev.

Referenced by move_to_ready_list(), and reduce_dependencies().

 {
     te->pending_prev->pending_next = te->pending_next;
     te->pending_next->pending_prev = te->pending_prev;
     te->pending_prev = NULL;
     te->pending_next = NULL;
 }

◆ pop_next_work_item()

static TocEntry * pop_next_work_item	(	ArchiveHandle *	AH,
		ParallelReadyList *	ready_list,
		ParallelState *	pstate
	)

static

Definition at line 4374 of file pg_backup_archiver.c.

References _parallelReadyList::first_te, has_lock_conflicts(), i, ParallelState::numWorkers, pg_log_debug, ready_list_remove(), ready_list_sort(), ParallelState::te, and _parallelReadyList::tes.

Referenced by restore_toc_entries_parallel().

 {
     /*
      * Sort the ready_list so that we'll tackle larger jobs first.
      */
     ready_list_sort(ready_list);
 
     /*
      * Search the ready_list until we find a suitable item.
      */
     for (int i = ready_list->first_te; i <= ready_list->last_te; i++)
     {
         TocEntry   *te = ready_list->tes[i];
         bool        conflicts = false;
 
         /*
          * Check to see if the item would need exclusive lock on something
          * that a currently running item also needs lock on, or vice versa. If
          * so, we don't want to schedule them together.
          */
         for (int k = 0; k < pstate->numWorkers; k++)
         {
             TocEntry   *running_te = pstate->te[k];
 
             if (running_te == NULL)
                 continue;
             if (has_lock_conflicts(te, running_te) ||
                 has_lock_conflicts(running_te, te))
             {
                 conflicts = true;
                 break;
             }
         }
 
         if (conflicts)
             continue;
 
         /* passed all tests, so this item can run */
         ready_list_remove(ready_list, i);
         return te;
     }
 
     pg_log_debug("no item ready");
     return NULL;
 }

◆ PrintTOCSummary()

void PrintTOCSummary ( Archive * AHX )

Definition at line 1119 of file pg_backup_archiver.c.

References _tocEntryRequired(), ahprintf(), archCustom, _archiveHandle::archdbname, archDirectory, ARCHIVE_MAJOR, ARCHIVE_MINOR, ARCHIVE_REV, _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, archTar, _tocEntry::catalogId, _archiveHandle::compression, _archiveHandle::createDate, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dumpId, _restoreOptions::filename, _archiveHandle::format, free, i, _archiveHandle::intSize, _tocEntry::nDeps, _tocEntry::next, _archiveHandle::offSize, CatalogId::oid, _tocEntry::owner, PGDUMP_STRFTIME_FMT, _archiveHandle::public, REQ_DATA, REQ_SCHEMA, RestoreOutput(), Archive::ropt, sanitize_line(), SaveOutput(), _tocEntry::section, SECTION_NONE, SECTION_PRE_DATA, SetOutput(), _restoreOptions::strict_names, StrictNamesCheck(), CatalogId::tableoid, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, _restoreOptions::verbose, and _archiveHandle::version.

Referenced by main().

 {
     ArchiveHandle *AH = (ArchiveHandle *) AHX;
     RestoreOptions *ropt = AH->public.ropt;
     TocEntry   *te;
     teSection   curSection;
     OutputContext sav;
     const char *fmtName;
     char        stamp_str[64];
 
     sav = SaveOutput(AH);
     if (ropt->filename)
         SetOutput(AH, ropt->filename, 0 /* no compression */ );
 
     if (strftime(stamp_str, sizeof(stamp_str), PGDUMP_STRFTIME_FMT,
                  localtime(&AH->createDate)) == 0)
         strcpy(stamp_str, "[unknown]");
 
     ahprintf(AH, ";\n; Archive created at %s\n", stamp_str);
     ahprintf(AH, ";     dbname: %s\n;     TOC Entries: %d\n;     Compression: %d\n",
              sanitize_line(AH->archdbname, false),
              AH->tocCount, AH->compression);
 
     switch (AH->format)
     {
         case archCustom:
             fmtName = "CUSTOM";
             break;
         case archDirectory:
             fmtName = "DIRECTORY";
             break;
         case archTar:
             fmtName = "TAR";
             break;
         default:
             fmtName = "UNKNOWN";
     }
 
     ahprintf(AH, ";     Dump Version: %d.%d-%d\n",
              ARCHIVE_MAJOR(AH->version), ARCHIVE_MINOR(AH->version), ARCHIVE_REV(AH->version));
     ahprintf(AH, ";     Format: %s\n", fmtName);
     ahprintf(AH, ";     Integer: %d bytes\n", (int) AH->intSize);
     ahprintf(AH, ";     Offset: %d bytes\n", (int) AH->offSize);
     if (AH->archiveRemoteVersion)
         ahprintf(AH, ";     Dumped from database version: %s\n",
                  AH->archiveRemoteVersion);
     if (AH->archiveDumpVersion)
         ahprintf(AH, ";     Dumped by pg_dump version: %s\n",
                  AH->archiveDumpVersion);
 
     ahprintf(AH, ";\n;\n; Selected TOC Entries:\n;\n");
 
     curSection = SECTION_PRE_DATA;
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         if (te->section != SECTION_NONE)
             curSection = te->section;
         if (ropt->verbose ||
             (_tocEntryRequired(te, curSection, AH) & (REQ_SCHEMA | REQ_DATA)) != 0)
         {
             char       *sanitized_name;
             char       *sanitized_schema;
             char       *sanitized_owner;
 
             /*
              */
             sanitized_name = sanitize_line(te->tag, false);
             sanitized_schema = sanitize_line(te->namespace, true);
             sanitized_owner = sanitize_line(te->owner, false);
 
             ahprintf(AH, "%d; %u %u %s %s %s %s\n", te->dumpId,
                      te->catalogId.tableoid, te->catalogId.oid,
                      te->desc, sanitized_schema, sanitized_name,
                      sanitized_owner);
 
             free(sanitized_name);
             free(sanitized_schema);
             free(sanitized_owner);
         }
         if (ropt->verbose && te->nDeps > 0)
         {
             int         i;
 
             ahprintf(AH, ";\tdepends on:");
             for (i = 0; i < te->nDeps; i++)
                 ahprintf(AH, " %d", te->dependencies[i]);
             ahprintf(AH, "\n");
         }
     }
 
     /* Enforce strict names checking */
     if (ropt->strict_names)
         StrictNamesCheck(ropt);
 
     if (ropt->filename)
         RestoreOutput(AH, sav);
 }

◆ ProcessArchiveRestoreOptions()

void ProcessArchiveRestoreOptions ( Archive * AHX )

Definition at line 289 of file pg_backup_archiver.c.

References _tocEntryRequired(), archModeRead, fatal, _archiveHandle::mode, _tocEntry::next, pg_log_warning, _archiveHandle::public, _tocEntry::reqs, Archive::ropt, _tocEntry::section, SECTION_DATA, SECTION_NONE, SECTION_POST_DATA, SECTION_PRE_DATA, _restoreOptions::strict_names, StrictNamesCheck(), and _archiveHandle::toc.

Referenced by main().

 {
     ArchiveHandle *AH = (ArchiveHandle *) AHX;
     RestoreOptions *ropt = AH->public.ropt;
     TocEntry   *te;
     teSection   curSection;
 
     /* Decide which TOC entries will be dumped/restored, and mark them */
     curSection = SECTION_PRE_DATA;
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         /*
          * When writing an archive, we also take this opportunity to check
          * that we have generated the entries in a sane order that respects
          * the section divisions.  When reading, don't complain, since buggy
          * old versions of pg_dump might generate out-of-order archives.
          */
         if (AH->mode != archModeRead)
         {
             switch (te->section)
             {
                 case SECTION_NONE:
                     /* ok to be anywhere */
                     break;
                 case SECTION_PRE_DATA:
                     if (curSection != SECTION_PRE_DATA)
                         pg_log_warning("archive items not in correct section order");
                     break;
                 case SECTION_DATA:
                     if (curSection == SECTION_POST_DATA)
                         pg_log_warning("archive items not in correct section order");
                     break;
                 case SECTION_POST_DATA:
                     /* ok no matter which section we were in */
                     break;
                 default:
                     fatal("unexpected section code %d",
                           (int) te->section);
                     break;
             }
         }
 
         if (te->section != SECTION_NONE)
             curSection = te->section;
 
         te->reqs = _tocEntryRequired(te, curSection, AH);
     }
 
     /* Enforce strict names checking */
     if (ropt->strict_names)
         StrictNamesCheck(ropt);
 }

◆ processEncodingEntry()

static void processEncodingEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 2718 of file pg_backup_archiver.c.

References _tocEntry::defn, encoding, Archive::encoding, fatal, free, pg_char_to_encoding(), pg_strdup(), and _archiveHandle::public.

Referenced by ReadToc().

 {
     /* te->defn should have the form SET client_encoding = 'foo'; */
     char       *defn = pg_strdup(te->defn);
     char       *ptr1;
     char       *ptr2 = NULL;
     int         encoding;
 
     ptr1 = strchr(defn, '\'');
     if (ptr1)
         ptr2 = strchr(++ptr1, '\'');
     if (ptr2)
     {
         *ptr2 = '\0';
         encoding = pg_char_to_encoding(ptr1);
         if (encoding < 0)
             fatal("unrecognized encoding \"%s\"",
                   ptr1);
         AH->public.encoding = encoding;
     }
     else
         fatal("invalid ENCODING item: %s",
               te->defn);
 
     free(defn);
 }

◆ processSearchPathEntry()

static void processSearchPathEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 2762 of file pg_backup_archiver.c.

References _tocEntry::defn, pg_strdup(), _archiveHandle::public, and Archive::searchpath.

Referenced by ReadToc().

 {
     /*
      * te->defn should contain a command to set search_path.  We just copy it
      * verbatim for use later.
      */
     AH->public.searchpath = pg_strdup(te->defn);
 }

◆ processStdStringsEntry()

static void processStdStringsEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 2746 of file pg_backup_archiver.c.

References _tocEntry::defn, fatal, _archiveHandle::public, and Archive::std_strings.

Referenced by ReadToc().

 {
     /* te->defn should have the form SET standard_conforming_strings = 'x'; */
     char       *ptr1;
 
     ptr1 = strchr(te->defn, '\'');
     if (ptr1 && strncmp(ptr1, "'on'", 4) == 0)
         AH->public.std_strings = true;
     else if (ptr1 && strncmp(ptr1, "'off'", 5) == 0)
         AH->public.std_strings = false;
     else
         fatal("invalid STDSTRINGS item: %s",
               te->defn);
 }

◆ ReadHead()

void ReadHead ( ArchiveHandle * AH )

Definition at line 3769 of file pg_backup_archiver.c.

References _archiveHandle::archdbname, _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, _archiveHandle::compression, _archiveHandle::createDate, fatal, _archiveHandle::format, _archiveHandle::intSize, K_VERS_1_0, K_VERS_1_10, K_VERS_1_2, K_VERS_1_4, K_VERS_1_7, K_VERS_MAX, MAKE_ARCHIVE_VERSION, _archiveHandle::offSize, pg_log_warning, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::readHeader, ReadInt(), ReadStr(), tm, _archiveHandle::version, and Z_DEFAULT_COMPRESSION.

Referenced by InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), and InitArchiveFmt_Tar().

 {
     char        tmpMag[7];
     int         fmt;
     struct tm   crtm;
 
     /*
      * If we haven't already read the header, do so.
      *
      * NB: this code must agree with _discoverArchiveFormat().  Maybe find a
      * way to unify the cases?
      */
     if (!AH->readHeader)
     {
         char        vmaj,
                     vmin,
                     vrev;
 
         AH->ReadBufPtr(AH, tmpMag, 5);
 
         if (strncmp(tmpMag, "PGDMP", 5) != 0)
             fatal("did not find magic string in file header");
 
         vmaj = AH->ReadBytePtr(AH);
         vmin = AH->ReadBytePtr(AH);
 
         if (vmaj > 1 || (vmaj == 1 && vmin > 0))    /* Version > 1.0 */
             vrev = AH->ReadBytePtr(AH);
         else
             vrev = 0;
 
         AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
 
         if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
             fatal("unsupported version (%d.%d) in file header",
                   vmaj, vmin);
 
         AH->intSize = AH->ReadBytePtr(AH);
         if (AH->intSize > 32)
             fatal("sanity check on integer size (%lu) failed",
                   (unsigned long) AH->intSize);
 
         if (AH->intSize > sizeof(int))
             pg_log_warning("archive was made on a machine with larger integers, some operations might fail");
 
         if (AH->version >= K_VERS_1_7)
             AH->offSize = AH->ReadBytePtr(AH);
         else
             AH->offSize = AH->intSize;
 
         fmt = AH->ReadBytePtr(AH);
 
         if (AH->format != fmt)
             fatal("expected format (%d) differs from format found in file (%d)",
                   AH->format, fmt);
     }
 
     if (AH->version >= K_VERS_1_2)
     {
         if (AH->version < K_VERS_1_4)
             AH->compression = AH->ReadBytePtr(AH);
         else
             AH->compression = ReadInt(AH);
     }
     else
         AH->compression = Z_DEFAULT_COMPRESSION;
 
 #ifndef HAVE_LIBZ
     if (AH->compression != 0)
         pg_log_warning("archive is compressed, but this installation does not support compression -- no data will be available");
 #endif
 
     if (AH->version >= K_VERS_1_4)
     {
         crtm.tm_sec = ReadInt(AH);
         crtm.tm_min = ReadInt(AH);
         crtm.tm_hour = ReadInt(AH);
         crtm.tm_mday = ReadInt(AH);
         crtm.tm_mon = ReadInt(AH);
         crtm.tm_year = ReadInt(AH);
         crtm.tm_isdst = ReadInt(AH);
 
         AH->archdbname = ReadStr(AH);
 
         AH->createDate = mktime(&crtm);
 
         if (AH->createDate == (time_t) -1)
             pg_log_warning("invalid creation date in header");
     }
 
     if (AH->version >= K_VERS_1_10)
     {
         AH->archiveRemoteVersion = ReadStr(AH);
         AH->archiveDumpVersion = ReadStr(AH);
     }
 }

◆ ReadInt()

int ReadInt ( ArchiveHandle * AH )

Definition at line 2009 of file pg_backup_archiver.c.

References _archiveHandle::intSize, K_VERS_1_0, _archiveHandle::ReadBytePtr, sign, and _archiveHandle::version.

Referenced by _CustomReadFunc(), _LoadBlobs(), _readBlockHeader(), _ReadExtraToc(), _skipBlobs(), _skipData(), ReadHead(), ReadOffset(), ReadStr(), and ReadToc().

 {
     int         res = 0;
     int         bv,
                 b;
     int         sign = 0;       /* Default positive */
     int         bitShift = 0;
 
     if (AH->version > K_VERS_1_0)
         /* Read a sign byte */
         sign = AH->ReadBytePtr(AH);
 
     for (b = 0; b < AH->intSize; b++)
     {
         bv = AH->ReadBytePtr(AH) & 0xFF;
         if (bv != 0)
             res = res + (bv << bitShift);
         bitShift += 8;
     }
 
     if (sign)
         res = -res;
 
     return res;
 }

◆ ReadOffset()

int ReadOffset	(	ArchiveHandle *	AH,
		pgoff_t *	o
	)

Definition at line 1914 of file pg_backup_archiver.c.

References fatal, i, K_OFFSET_NO_DATA, K_OFFSET_POS_NOT_SET, K_OFFSET_POS_SET, K_VERS_1_7, _archiveHandle::offSize, pgoff_t, _archiveHandle::ReadBytePtr, ReadInt(), and _archiveHandle::version.

Referenced by _ReadExtraToc().

 {
     int         i;
     int         off;
     int         offsetFlg;
 
     /* Initialize to zero */
     *o = 0;
 
     /* Check for old version */
     if (AH->version < K_VERS_1_7)
     {
         /* Prior versions wrote offsets using WriteInt */
         i = ReadInt(AH);
         /* -1 means not set */
         if (i < 0)
             return K_OFFSET_POS_NOT_SET;
         else if (i == 0)
             return K_OFFSET_NO_DATA;
 
         /* Cast to pgoff_t because it was written as an int. */
         *o = (pgoff_t) i;
         return K_OFFSET_POS_SET;
     }
 
     /*
      * Read the flag indicating the state of the data pointer. Check if valid
      * and die if not.
      *
      * This used to be handled by a negative or zero pointer, now we use an
      * extra byte specifically for the state.
      */
     offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
 
     switch (offsetFlg)
     {
         case K_OFFSET_POS_NOT_SET:
         case K_OFFSET_NO_DATA:
         case K_OFFSET_POS_SET:
 
             break;
 
         default:
             fatal("unexpected data offset flag %d", offsetFlg);
     }
 
     /*
      * Read the bytes
      */
     for (off = 0; off < AH->offSize; off++)
     {
         if (off < sizeof(pgoff_t))
             *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
         else
         {
             if (AH->ReadBytePtr(AH) != 0)
                 fatal("file offset in dump file is too large");
         }
     }
 
     return offsetFlg;
 }

◆ ReadStr()

char* ReadStr ( ArchiveHandle * AH )

Definition at line 2055 of file pg_backup_archiver.c.

References buf, pg_malloc(), _archiveHandle::ReadBufPtr, and ReadInt().

Referenced by _ReadExtraToc(), ReadHead(), and ReadToc().

 {
     char       *buf;
     int         l;
 
     l = ReadInt(AH);
     if (l < 0)
         buf = NULL;
     else
     {
         buf = (char *) pg_malloc(l + 1);
         AH->ReadBufPtr(AH, (void *) buf, l);
 
         buf[l] = '\0';
     }
 
     return buf;
 }

◆ ReadToc()

void ReadToc ( ArchiveHandle * AH )

Definition at line 2563 of file pg_backup_archiver.c.

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, fatal, free, _tocEntry::hadDumper, i, InvalidOid, K_VERS_1_10, K_VERS_1_11, K_VERS_1_14, K_VERS_1_3, K_VERS_1_5, K_VERS_1_6, K_VERS_1_8, K_VERS_1_9, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, CatalogId::oid, _tocEntry::owner, pg_log_debug, pg_log_warning, pg_malloc(), pg_malloc0(), pg_realloc(), _tocEntry::prev, processEncodingEntry(), processSearchPathEntry(), processStdStringsEntry(), _archiveHandle::ReadExtraTocPtr, ReadInt(), ReadStr(), _tocEntry::section, SECTION_DATA, SECTION_NONE, SECTION_POST_DATA, SECTION_PRE_DATA, _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and _archiveHandle::version.

Referenced by InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), and InitArchiveFmt_Tar().

 {
     int         i;
     char       *tmp;
     DumpId     *deps;
     int         depIdx;
     int         depSize;
     TocEntry   *te;
 
     AH->tocCount = ReadInt(AH);
     AH->maxDumpId = 0;
 
     for (i = 0; i < AH->tocCount; i++)
     {
         te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
         te->dumpId = ReadInt(AH);
 
         if (te->dumpId > AH->maxDumpId)
             AH->maxDumpId = te->dumpId;
 
         /* Sanity check */
         if (te->dumpId <= 0)
             fatal("entry ID %d out of range -- perhaps a corrupt TOC",
                   te->dumpId);
 
         te->hadDumper = ReadInt(AH);
 
         if (AH->version >= K_VERS_1_8)
         {
             tmp = ReadStr(AH);
             sscanf(tmp, "%u", &te->catalogId.tableoid);
             free(tmp);
         }
         else
             te->catalogId.tableoid = InvalidOid;
         tmp = ReadStr(AH);
         sscanf(tmp, "%u", &te->catalogId.oid);
         free(tmp);
 
         te->tag = ReadStr(AH);
         te->desc = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_11)
         {
             te->section = ReadInt(AH);
         }
         else
         {
             /*
              * Rules for pre-8.4 archives wherein pg_dump hasn't classified
              * the entries into sections.  This list need not cover entry
              * types added later than 8.4.
              */
             if (strcmp(te->desc, "COMMENT") == 0 ||
                 strcmp(te->desc, "ACL") == 0 ||
                 strcmp(te->desc, "ACL LANGUAGE") == 0)
                 te->section = SECTION_NONE;
             else if (strcmp(te->desc, "TABLE DATA") == 0 ||
                      strcmp(te->desc, "BLOBS") == 0 ||
                      strcmp(te->desc, "BLOB COMMENTS") == 0)
                 te->section = SECTION_DATA;
             else if (strcmp(te->desc, "CONSTRAINT") == 0 ||
                      strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
                      strcmp(te->desc, "FK CONSTRAINT") == 0 ||
                      strcmp(te->desc, "INDEX") == 0 ||
                      strcmp(te->desc, "RULE") == 0 ||
                      strcmp(te->desc, "TRIGGER") == 0)
                 te->section = SECTION_POST_DATA;
             else
                 te->section = SECTION_PRE_DATA;
         }
 
         te->defn = ReadStr(AH);
         te->dropStmt = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_3)
             te->copyStmt = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_6)
             te->namespace = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_10)
             te->tablespace = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_14)
             te->tableam = ReadStr(AH);
 
         te->owner = ReadStr(AH);
         if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
             pg_log_warning("restoring tables WITH OIDS is not supported anymore");
 
         /* Read TOC entry dependencies */
         if (AH->version >= K_VERS_1_5)
         {
             depSize = 100;
             deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
             depIdx = 0;
             for (;;)
             {
                 tmp = ReadStr(AH);
                 if (!tmp)
                     break;      /* end of list */
                 if (depIdx >= depSize)
                 {
                     depSize *= 2;
                     deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depSize);
                 }
                 sscanf(tmp, "%d", &deps[depIdx]);
                 free(tmp);
                 depIdx++;
             }
 
             if (depIdx > 0)     /* We have a non-null entry */
             {
                 deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depIdx);
                 te->dependencies = deps;
                 te->nDeps = depIdx;
             }
             else
             {
                 free(deps);
                 te->dependencies = NULL;
                 te->nDeps = 0;
             }
         }
         else
         {
             te->dependencies = NULL;
             te->nDeps = 0;
         }
         te->dataLength = 0;
 
         if (AH->ReadExtraTocPtr)
             AH->ReadExtraTocPtr(AH, te);
 
         pg_log_debug("read TOC entry %d (ID %d) for %s %s",
                      i, te->dumpId, te->desc, te->tag);
 
         /* link completed entry into TOC circular list */
         te->prev = AH->toc->prev;
         AH->toc->prev->next = te;
         AH->toc->prev = te;
         te->next = AH->toc;
 
         /* special processing immediately upon read for some items */
         if (strcmp(te->desc, "ENCODING") == 0)
             processEncodingEntry(AH, te);
         else if (strcmp(te->desc, "STDSTRINGS") == 0)
             processStdStringsEntry(AH, te);
         else if (strcmp(te->desc, "SEARCHPATH") == 0)
             processSearchPathEntry(AH, te);
     }
 }

◆ ready_list_free()

static void ready_list_free ( ParallelReadyList * ready_list )

static

Definition at line 4254 of file pg_backup_archiver.c.

References pg_free(), and _parallelReadyList::tes.

Referenced by restore_toc_entries_parallel().

 {
     pg_free(ready_list->tes);
 }

◆ ready_list_init()

static void ready_list_init	(	ParallelReadyList *	ready_list,
		int	tocCount
	)

static

Definition at line 4241 of file pg_backup_archiver.c.

References _parallelReadyList::first_te, _parallelReadyList::last_te, pg_malloc(), _parallelReadyList::sorted, and _parallelReadyList::tes.

Referenced by restore_toc_entries_parallel().

 {
     ready_list->tes = (TocEntry **)
         pg_malloc(tocCount * sizeof(TocEntry *));
     ready_list->first_te = 0;
     ready_list->last_te = -1;
     ready_list->sorted = false;
 }

◆ ready_list_insert()

static void ready_list_insert	(	ParallelReadyList *	ready_list,
		TocEntry *	te
	)

static

Definition at line 4261 of file pg_backup_archiver.c.

References _parallelReadyList::last_te, _parallelReadyList::sorted, and _parallelReadyList::tes.

Referenced by move_to_ready_list(), and reduce_dependencies().

 {
     ready_list->tes[++ready_list->last_te] = te;
     /* List is (probably) not sorted anymore. */
     ready_list->sorted = false;
 }

◆ ready_list_remove()

static void ready_list_remove	(	ParallelReadyList *	ready_list,
		int	i
	)

static

Definition at line 4270 of file pg_backup_archiver.c.

References Assert, _parallelReadyList::first_te, and _parallelReadyList::tes.

Referenced by pop_next_work_item().

 {
     int         f = ready_list->first_te;
 
     Assert(i >= f && i <= ready_list->last_te);
 
     /*
      * In the typical case where the item to be removed is the first ready
      * entry, we need only increment first_te to remove it.  Otherwise, move
      * the entries before it to compact the list.  (This preserves sortedness,
      * if any.)  We could alternatively move the entries after i, but there
      * are typically many more of those.
      */
     if (i > f)
     {
         TocEntry  **first_te_ptr = &ready_list->tes[f];
 
         memmove(first_te_ptr + 1, first_te_ptr, (i - f) * sizeof(TocEntry *));
     }
     ready_list->first_te++;
 }

◆ ready_list_sort()

static void ready_list_sort ( ParallelReadyList * ready_list )

static

Definition at line 4294 of file pg_backup_archiver.c.

References _parallelReadyList::first_te, _parallelReadyList::last_te, qsort, _parallelReadyList::sorted, _parallelReadyList::tes, and TocEntrySizeCompare().

Referenced by pop_next_work_item().

 {
     if (!ready_list->sorted)
     {
         int         n = ready_list->last_te - ready_list->first_te + 1;
 
         if (n > 1)
             qsort(ready_list->tes + ready_list->first_te, n,
                   sizeof(TocEntry *),
                   TocEntrySizeCompare);
         ready_list->sorted = true;
     }
 }

◆ reduce_dependencies()

static void reduce_dependencies	(	ArchiveHandle *	AH,
		TocEntry *	te,
		ParallelReadyList *	ready_list
	)

static

Definition at line 4723 of file pg_backup_archiver.c.

References _tocEntryRestorePass(), Assert, _tocEntry::depCount, _tocEntry::dumpId, i, _tocEntry::nRevDeps, pending_list_remove(), _tocEntry::pending_prev, pg_log_debug, ready_list_insert(), _archiveHandle::restorePass, _tocEntry::revDeps, and _archiveHandle::tocsByDumpId.

Referenced by mark_restore_job_done(), restore_toc_entries_parallel(), and restore_toc_entries_prefork().

 {
     int         i;
 
     pg_log_debug("reducing dependencies for %d", te->dumpId);
 
     for (i = 0; i < te->nRevDeps; i++)
     {
         TocEntry   *otherte = AH->tocsByDumpId[te->revDeps[i]];
 

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ TEXT_DUMP_HEADER

◆ TEXT_DUMPALL_HEADER

Typedef Documentation

◆ OutputContext

◆ ParallelReadyList

Function Documentation

◆ _allocAH()

◆ _becomeOwner()

◆ _becomeUser()

◆ _disableTriggersIfNecessary()

◆ _discoverArchiveFormat()

◆ _doSetFixedOutputState()

◆ _doSetSessionAuth()

◆ _enableTriggersIfNecessary()

◆ _getObjectDescription()

◆ _moveBefore()

◆ _printTocEntry()

◆ _reconnectToDB()

◆ _selectOutputSchema()

◆ _selectTableAccessMethod()

◆ _selectTablespace()

◆ _tocEntryIsACL()

◆ _tocEntryRequired()

◆ _tocEntryRestorePass()

◆ ahprintf()

◆ ahwrite()

◆ ArchiveEntry()

◆ archprintf()

◆ archputs()

◆ buildTocEntryArrays()

◆ checkSeek()

◆ CloneArchive()

◆ CloseArchive()

◆ CreateArchive()

◆ DeCloneArchive()

◆ dump_lo_buf()

◆ dumpOptionsFromRestoreOptions()

◆ dumpTimestamp()

◆ EndBlob()

◆ EndRestoreBlob()

◆ EndRestoreBlobs()

◆ fix_dependencies()

◆ getTocEntryByDumpId()

◆ has_lock_conflicts()

◆ identify_locking_dependencies()

◆ inhibit_data_for_failed_table()

◆ InitDumpOptions()

◆ mark_create_done()

◆ mark_dump_job_done()

◆ mark_restore_job_done()

◆ move_to_ready_list()

◆ NewDumpOptions()

◆ NewRestoreOptions()

◆ OpenArchive()

◆ parallel_restore()

◆ pending_list_append()

◆ pending_list_header_init()

◆ pending_list_remove()

◆ pop_next_work_item()

◆ PrintTOCSummary()

◆ ProcessArchiveRestoreOptions()

◆ processEncodingEntry()

◆ processSearchPathEntry()

◆ processStdStringsEntry()

◆ ReadHead()

◆ ReadInt()

◆ ReadOffset()

◆ ReadStr()

◆ ReadToc()

◆ ready_list_free()

◆ ready_list_init()

◆ ready_list_insert()

◆ ready_list_remove()

◆ ready_list_sort()

◆ reduce_dependencies()