pg_backup.h File Reference

#include "common/compression.h"
#include "common/file_utils.h"
#include "fe_utils/simple_list.h"
#include "libpq-fe.h"

Include dependency graph for pg_backup.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_connParams
struct	_restoreOptions
struct	_dumpOptions
struct	Archive
struct	CatalogId

Macros
#define	InvalidDumpId   0
#define	appendStringLiteralAH(buf, str, AH)    appendStringLiteral(buf, str, (AH)->encoding, (AH)->std_strings)

Typedefs
typedef enum trivalue	trivalue
typedef enum _archiveFormat	ArchiveFormat
typedef enum _archiveMode	ArchiveMode
typedef enum _teSection	teSection
typedef struct _connParams	ConnParams
typedef struct _restoreOptions	RestoreOptions
typedef struct _dumpOptions	DumpOptions
typedef struct Archive	Archive
typedef int	DumpId
typedef int(*	DataDumperPtr) (Archive *AH, const void *userArg)
typedef void(*	SetupWorkerPtrType) (Archive *AH)

Enumerations
enum	trivalue {   TRI_DEFAULT , TRI_NO , TRI_YES , TRI_DEFAULT ,   TRI_NO , TRI_YES , TRI_DEFAULT , TRI_NO ,   TRI_YES , TRI_DEFAULT , TRI_NO , TRI_YES }
enum	_archiveFormat {   archUnknown = 0 , archCustom = 1 , archTar = 3 , archNull = 4 ,   archDirectory = 5 }
enum	_archiveMode { archModeAppend , archModeWrite , archModeRead }
enum	_teSection { SECTION_NONE = 1 , SECTION_PRE_DATA , SECTION_DATA , SECTION_POST_DATA }
enum	_dumpPreparedQueries {   PREPQUERY_DUMPAGG , PREPQUERY_DUMPBASETYPE , PREPQUERY_DUMPCOMPOSITETYPE , PREPQUERY_DUMPDOMAIN ,   PREPQUERY_DUMPENUMTYPE , PREPQUERY_DUMPFUNC , PREPQUERY_DUMPOPR , PREPQUERY_DUMPRANGETYPE ,   PREPQUERY_DUMPTABLEATTACH , PREPQUERY_GETCOLUMNACLS , PREPQUERY_GETDOMAINCONSTRAINTS , NUM_PREP_QUERIES }

Functions
void	ConnectDatabase (Archive *AHX, const ConnParams *cparams, bool isReconnect)
void	DisconnectDatabase (Archive *AHX)
PGconn *	GetConnection (Archive *AHX)
void	WriteData (Archive *AHX, const void *data, size_t dLen)
int	StartLO (Archive *AHX, Oid oid)
int	EndLO (Archive *AHX, Oid oid)
void	CloseArchive (Archive *AHX)
void	SetArchiveOptions (Archive *AH, DumpOptions *dopt, RestoreOptions *ropt)
void	ProcessArchiveRestoreOptions (Archive *AHX)
void	RestoreArchive (Archive *AHX)
Archive *	OpenArchive (const char *FileSpec, const ArchiveFormat fmt)
Archive *	CreateArchive (const char *FileSpec, const ArchiveFormat fmt, const pg_compress_specification compression_spec, bool dosync, ArchiveMode mode, SetupWorkerPtrType setupDumpWorker, DataDirSyncMethod sync_method)
void	PrintTOCSummary (Archive *AHX)
RestoreOptions *	NewRestoreOptions (void)
DumpOptions *	NewDumpOptions (void)
void	InitDumpOptions (DumpOptions *opts)
DumpOptions *	dumpOptionsFromRestoreOptions (RestoreOptions *ropt)
void	SortTocFromFile (Archive *AHX)
void	archputs (const char *s, Archive *AH)
int	archprintf (Archive *AH, const char *fmt,...) pg_attribute_printf(2

Macro Definition Documentation

appendStringLiteralAH

#define appendStringLiteralAH	(		buf,
			str,
			AH
	)		appendStringLiteral(buf, str, (AH)->encoding, (AH)->std_strings)

Definition at line 332 of file pg_backup.h.

InvalidDumpId

#define InvalidDumpId   0

Definition at line 272 of file pg_backup.h.

Typedef Documentation

Archive

typedef struct Archive Archive

ArchiveFormat

typedef enum _archiveFormat ArchiveFormat

ArchiveMode

typedef enum _archiveMode ArchiveMode

ConnParams

typedef struct _connParams ConnParams

DataDumperPtr

typedef int(* DataDumperPtr) (Archive *AH, const void *userArg)

Definition at line 278 of file pg_backup.h.

DumpId

typedef int DumpId

Definition at line 270 of file pg_backup.h.

DumpOptions

typedef struct _dumpOptions DumpOptions

RestoreOptions

typedef struct _restoreOptions RestoreOptions

SetupWorkerPtrType

typedef void(* SetupWorkerPtrType) (Archive *AH)

Definition at line 280 of file pg_backup.h.

teSection

typedef enum _teSection teSection

trivalue

typedef enum trivalue trivalue

Enumeration Type Documentation

_archiveFormat

enum _archiveFormat

Enumerator
archUnknown
archCustom
archTar
archNull
archDirectory

Definition at line 39 of file pg_backup.h.

{
    archUnknown = 0,
    archCustom = 1,
    archTar = 3,
    archNull = 4,
    archDirectory = 5,
} ArchiveFormat;

_archiveMode

enum _archiveMode

Enumerator
archModeAppend
archModeWrite
archModeRead

Definition at line 48 of file pg_backup.h.

{
    archModeAppend,
    archModeWrite,
    archModeRead,
} ArchiveMode;

_dumpPreparedQueries

enum _dumpPreparedQueries

Enumerator
PREPQUERY_DUMPAGG
PREPQUERY_DUMPBASETYPE
PREPQUERY_DUMPCOMPOSITETYPE
PREPQUERY_DUMPDOMAIN
PREPQUERY_DUMPENUMTYPE
PREPQUERY_DUMPFUNC
PREPQUERY_DUMPOPR
PREPQUERY_DUMPRANGETYPE
PREPQUERY_DUMPTABLEATTACH
PREPQUERY_GETCOLUMNACLS
PREPQUERY_GETDOMAINCONSTRAINTS
NUM_PREP_QUERIES

Definition at line 64 of file pg_backup.h.

{
    PREPQUERY_DUMPAGG,
    PREPQUERY_DUMPBASETYPE,
    PREPQUERY_DUMPCOMPOSITETYPE,
    PREPQUERY_DUMPDOMAIN,
    PREPQUERY_DUMPENUMTYPE,
    PREPQUERY_DUMPFUNC,
    PREPQUERY_DUMPOPR,
    PREPQUERY_DUMPRANGETYPE,
    PREPQUERY_DUMPTABLEATTACH,
    PREPQUERY_GETCOLUMNACLS,
    PREPQUERY_GETDOMAINCONSTRAINTS,
    NUM_PREP_QUERIES            /* must be last */
};

_teSection

enum _teSection

Enumerator
SECTION_NONE
SECTION_PRE_DATA
SECTION_DATA
SECTION_POST_DATA

Definition at line 55 of file pg_backup.h.

{
    SECTION_NONE = 1,           /* comments, ACLs, etc; can be anywhere */
    SECTION_PRE_DATA,           /* stuff to be processed before data */
    SECTION_DATA,               /* table data, large objects, LO comments */
    SECTION_POST_DATA,          /* stuff to be processed after data */
} teSection;

trivalue

enum trivalue

Enumerator
TRI_DEFAULT
TRI_NO
TRI_YES
TRI_DEFAULT
TRI_NO
TRI_YES
TRI_DEFAULT
TRI_NO
TRI_YES
TRI_DEFAULT
TRI_NO
TRI_YES

Definition at line 32 of file pg_backup.h.

{
    TRI_DEFAULT,
    TRI_NO,
    TRI_YES,
} trivalue;

Function Documentation

archprintf()

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

Referenced by dumpTableData_copy(), and dumpTableData_insert().

archputs()

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

Definition at line 1607 of file pg_backup_archiver.c.

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

References WriteData().

Referenced by dumpTableData_insert().

CloseArchive()

void CloseArchive

(

Archive *

AHX

)

Definition at line 252 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    AH->ClosePtr(AH);
 
    /* Close the output */
    errno = 0;
    if (!EndCompressFileHandle(AH->OF))
        pg_fatal("could not close output file: %m");
}

References _archiveHandle::ClosePtr, EndCompressFileHandle(), _archiveHandle::OF, and pg_fatal.

Referenced by main().

ConnectDatabase()

void ConnectDatabase	(	Archive *	AHX,
		const ConnParams *	cparams,
		bool	isReconnect
	)

Definition at line 110 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    trivalue    prompt_password;
    char       *password;
    bool        new_pass;
 
    if (AH->connection)
        pg_fatal("already connected to a database");
 
    /* Never prompt for a password during a reconnection */
    prompt_password = isReconnect ? TRI_NO : cparams->promptPassword;
 
    password = AH->savedPassword;
 
    if (prompt_password == TRI_YES && password == NULL)
        password = simple_prompt("Password: ", false);
 
    /*
     * Start the connection.  Loop until we have a password if requested by
     * backend.
     */
    do
    {
        const char *keywords[8];
        const char *values[8];
        int         i = 0;
 
        /*
         * If dbname is a connstring, its entries can override the other
         * values obtained from cparams; but in turn, override_dbname can
         * override the dbname component of it.
         */
        keywords[i] = "host";
        values[i++] = cparams->pghost;
        keywords[i] = "port";
        values[i++] = cparams->pgport;
        keywords[i] = "user";
        values[i++] = cparams->username;
        keywords[i] = "password";
        values[i++] = password;
        keywords[i] = "dbname";
        values[i++] = cparams->dbname;
        if (cparams->override_dbname)
        {
            keywords[i] = "dbname";
            values[i++] = cparams->override_dbname;
        }
        keywords[i] = "fallback_application_name";
        values[i++] = progname;
        keywords[i] = NULL;
        values[i++] = NULL;
        Assert(i <= lengthof(keywords));
 
        new_pass = false;
        AH->connection = PQconnectdbParams(keywords, values, true);
 
        if (!AH->connection)
            pg_fatal("could not connect to database");
 
        if (PQstatus(AH->connection) == CONNECTION_BAD &&
            PQconnectionNeedsPassword(AH->connection) &&
            password == NULL &&
            prompt_password != TRI_NO)
        {
            PQfinish(AH->connection);
            password = simple_prompt("Password: ", false);
            new_pass = true;
        }
    } while (new_pass);
 
    /* check to see that the backend connection was successfully made */
    if (PQstatus(AH->connection) == CONNECTION_BAD)
    {
        if (isReconnect)
            pg_fatal("reconnection failed: %s",
                     PQerrorMessage(AH->connection));
        else
            pg_fatal("%s",
                     PQerrorMessage(AH->connection));
    }
 
    /* Start strict; later phases may override this. */
    PQclear(ExecuteSqlQueryForSingleRow((Archive *) AH,
                                        ALWAYS_SECURE_SEARCH_PATH_SQL));
 
    if (password && password != AH->savedPassword)
        free(password);
 
    /*
     * We want to remember connection's actual password, whether or not we got
     * it by prompting.  So we don't just store the password variable.
     */
    if (PQconnectionUsedPassword(AH->connection))
    {
        free(AH->savedPassword);
        AH->savedPassword = pg_strdup(PQpass(AH->connection));
    }
 
    /* check for version mismatch */
    _check_database_version(AH);
 
    PQsetNoticeProcessor(AH->connection, notice_processor, NULL);
 
    /* arrange for SIGINT to issue a query cancel on this connection */
    set_archive_cancel_info(AH, AH->connection);
}

References _check_database_version(), ALWAYS_SECURE_SEARCH_PATH_SQL, Assert, _archiveHandle::connection, CONNECTION_BAD, _connParams::dbname, ExecuteSqlQueryForSingleRow(), free, i, lengthof, notice_processor(), _connParams::override_dbname, password, pg_fatal, pg_strdup(), _connParams::pghost, _connParams::pgport, PQclear(), PQconnectdbParams(), PQconnectionNeedsPassword(), PQconnectionUsedPassword(), PQerrorMessage(), PQfinish(), PQpass(), PQsetNoticeProcessor(), PQstatus(), progname, _connParams::promptPassword, _archiveHandle::savedPassword, set_archive_cancel_info(), simple_prompt(), TRI_NO, TRI_YES, _connParams::username, and values.

Referenced by CloneArchive(), main(), ReconnectToServer(), restore_toc_entries_postfork(), and RestoreArchive().

CreateArchive()

Archive* CreateArchive	(	const char *	FileSpec,
		const ArchiveFormat	fmt,
		const pg_compress_specification	compression_spec,
		bool	dosync,
		ArchiveMode	mode,
		SetupWorkerPtrType	setupDumpWorker,
		DataDirSyncMethod	sync_method
	)

Definition at line 221 of file pg_backup_archiver.c.

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

References _allocAH(), dosync, fmt, mode, setupDumpWorker(), and sync_method.

Referenced by main().

DisconnectDatabase()

void DisconnectDatabase

(

Archive *

AHX

)

Definition at line 225 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    char        errbuf[1];
 
    if (!AH->connection)
        return;
 
    if (AH->connCancel)
    {
        /*
         * If we have an active query, send a cancel before closing, ignoring
         * any errors.  This is of no use for a normal exit, but might be
         * helpful during pg_fatal().
         */
        if (PQtransactionStatus(AH->connection) == PQTRANS_ACTIVE)
            (void) PQcancel(AH->connCancel, errbuf, sizeof(errbuf));
 
        /*
         * Prevent signal handler from sending a cancel after this.
         */
        set_archive_cancel_info(AH, NULL);
    }
 
    PQfinish(AH->connection);
    AH->connection = NULL;
}

References _archiveHandle::connCancel, _archiveHandle::connection, PQcancel(), PQfinish(), PQTRANS_ACTIVE, PQtransactionStatus(), and set_archive_cancel_info().

Referenced by archive_close_connection(), restore_toc_entries_prefork(), RestoreArchive(), and RunWorker().

dumpOptionsFromRestoreOptions()

DumpOptions* dumpOptionsFromRestoreOptions

(

RestoreOptions *

ropt

)

Definition at line 157 of file pg_backup_archiver.c.

{
    DumpOptions *dopt = NewDumpOptions();
 
    /* this is the inverse of what's at the end of pg_dump.c's main() */
    dopt->cparams.dbname = ropt->cparams.dbname ? pg_strdup(ropt->cparams.dbname) : NULL;
    dopt->cparams.pgport = ropt->cparams.pgport ? pg_strdup(ropt->cparams.pgport) : NULL;
    dopt->cparams.pghost = ropt->cparams.pghost ? pg_strdup(ropt->cparams.pghost) : NULL;
    dopt->cparams.username = ropt->cparams.username ? pg_strdup(ropt->cparams.username) : NULL;
    dopt->cparams.promptPassword = ropt->cparams.promptPassword;
    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->outputNoTableAm = ropt->noTableAm;
    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;
}

References _restoreOptions::aclsSkip, _dumpOptions::aclsSkip, _restoreOptions::column_inserts, _dumpOptions::column_inserts, _restoreOptions::cparams, _dumpOptions::cparams, _restoreOptions::createDB, _restoreOptions::dataOnly, _dumpOptions::dataOnly, _connParams::dbname, _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::noTableAm, _restoreOptions::noTablespace, _dumpOptions::outputClean, _dumpOptions::outputCreateDB, _dumpOptions::outputNoOwner, _dumpOptions::outputNoTableAm, _dumpOptions::outputNoTablespaces, _dumpOptions::outputSuperuser, pg_strdup(), _connParams::pghost, _connParams::pgport, _connParams::promptPassword, _restoreOptions::schemaOnly, _dumpOptions::schemaOnly, _restoreOptions::sequence_data, _dumpOptions::sequence_data, _restoreOptions::superuser, _restoreOptions::use_setsessauth, _dumpOptions::use_setsessauth, and _connParams::username.

Referenced by SetArchiveOptions().

EndLO()

int EndLO	(	Archive *	AHX,
		Oid	oid
	)

Definition at line 1385 of file pg_backup_archiver.c.

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

References _archiveHandle::currToc, and _archiveHandle::EndLOPtr.

Referenced by dumpLOs().

GetConnection()

PGconn* GetConnection

(

Archive *

AHX

)

Definition at line 254 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    return AH->connection;
}

References _archiveHandle::connection.

InitDumpOptions()

void InitDumpOptions

(

DumpOptions *

opts

)

Definition at line 143 of file pg_backup_archiver.c.

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

References DUMP_UNSECTIONED, opts, and TRI_DEFAULT.

Referenced by main(), and NewDumpOptions().

NewDumpOptions()

DumpOptions* NewDumpOptions

(

void

)

Definition at line 131 of file pg_backup_archiver.c.

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

References InitDumpOptions(), opts, and pg_malloc().

Referenced by dumpOptionsFromRestoreOptions().

NewRestoreOptions()

RestoreOptions* NewRestoreOptions

(

void

)

Definition at line 1071 of file pg_backup_archiver.c.

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

References archUnknown, DUMP_UNSECTIONED, opts, PG_COMPRESSION_NONE, pg_malloc0(), and TRI_DEFAULT.

Referenced by _CloseArchive(), and main().

OpenArchive()

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

Definition at line 237 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH;
    pg_compress_specification compression_spec = {0};
 
    compression_spec.algorithm = PG_COMPRESSION_NONE;
    AH = _allocAH(FileSpec, fmt, compression_spec, true,
                  archModeRead, setupRestoreWorker,
                  DATA_DIR_SYNC_METHOD_FSYNC);
 
    return (Archive *) AH;
}

References _allocAH(), pg_compress_specification::algorithm, archModeRead, DATA_DIR_SYNC_METHOD_FSYNC, fmt, PG_COMPRESSION_NONE, and setupRestoreWorker().

Referenced by main().

PrintTOCSummary()

void PrintTOCSummary

(

Archive *

AHX

)

Definition at line 1262 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    RestoreOptions *ropt = AH->public.ropt;
    TocEntry   *te;
    pg_compress_specification out_compression_spec = {0};
    teSection   curSection;
    CompressFileHandle *sav;
    const char *fmtName;
    char        stamp_str[64];
 
    /* TOC is always uncompressed */
    out_compression_spec.algorithm = PG_COMPRESSION_NONE;
 
    sav = SaveOutput(AH);
    if (ropt->filename)
        SetOutput(AH, ropt->filename, out_compression_spec);
 
    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: %s\n",
             sanitize_line(AH->archdbname, false),
             AH->tocCount,
             get_compress_algorithm_name(AH->compression_spec.algorithm));
 
    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);
}

References _tocEntryRequired(), ahprintf(), pg_compress_specification::algorithm, archCustom, _archiveHandle::archdbname, archDirectory, ARCHIVE_MAJOR, ARCHIVE_MINOR, ARCHIVE_REV, _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, archTar, _tocEntry::catalogId, _archiveHandle::compression_spec, _archiveHandle::createDate, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dumpId, _restoreOptions::filename, _archiveHandle::format, free, get_compress_algorithm_name(), i, _archiveHandle::intSize, _tocEntry::nDeps, _tocEntry::next, _archiveHandle::offSize, CatalogId::oid, _tocEntry::owner, PG_COMPRESSION_NONE, 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().

ProcessArchiveRestoreOptions()

void ProcessArchiveRestoreOptions

(

Archive *

AHX

)

Definition at line 279 of file pg_backup_archiver.c.

{
    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:
                    pg_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);
}

References _tocEntryRequired(), archModeRead, _archiveHandle::mode, _tocEntry::next, pg_fatal, 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().

RestoreArchive()

void RestoreArchive

(

Archive *

AHX

)

Definition at line 334 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    RestoreOptions *ropt = AH->public.ropt;
    bool        parallel_mode;
    TocEntry   *te;
    CompressFileHandle *sav;
 
    AH->stage = STAGE_INITIALIZING;
 
    /*
     * If we're going to do parallel restore, there are some restrictions.
     */
    parallel_mode = (AH->public.numWorkers > 1 && ropt->useDB);
    if (parallel_mode)
    {
        /* We haven't got round to making this work for all archive formats */
        if (AH->ClonePtr == NULL || AH->ReopenPtr == NULL)
            pg_fatal("parallel restore is not supported with this archive file format");
 
        /* Doesn't work if the archive represents dependencies as OIDs */
        if (AH->version < K_VERS_1_8)
            pg_fatal("parallel restore is not supported with archives made by pre-8.0 pg_dump");
 
        /*
         * It's also not gonna work if we can't reopen the input file, so
         * let's try that immediately.
         */
        AH->ReopenPtr(AH);
    }
 
    /*
     * Make sure we won't need (de)compression we haven't got
     */
    if (AH->PrintTocDataPtr != NULL)
    {
        for (te = AH->toc->next; te != AH->toc; te = te->next)
        {
            if (te->hadDumper && (te->reqs & REQ_DATA) != 0)
            {
                char       *errmsg = supports_compression(AH->compression_spec);
 
                if (errmsg)
                    pg_fatal("cannot restore from compressed archive (%s)",
                             errmsg);
                else
                    break;
            }
        }
    }
 
    /*
     * Prepare index arrays, so we can assume we have them throughout restore.
     * It's possible we already did this, though.
     */
    if (AH->tocsByDumpId == NULL)
        buildTocEntryArrays(AH);
 
    /*
     * If we're using a DB connection, then connect it.
     */
    if (ropt->useDB)
    {
        pg_log_info("connecting to database for restore");
        if (AH->version < K_VERS_1_3)
            pg_fatal("direct database connections are not supported in pre-1.3 archives");
 
        /*
         * We don't want to guess at whether the dump will successfully
         * restore; allow the attempt regardless of the version of the restore
         * target.
         */
        AHX->minRemoteVersion = 0;
        AHX->maxRemoteVersion = 9999999;
 
        ConnectDatabase(AHX, &ropt->cparams, false);
 
        /*
         * If we're talking to the DB directly, don't send comments since they
         * obscure SQL when displaying errors
         */
        AH->noTocComments = 1;
    }
 
    /*
     * Work out if we have an implied data-only restore. This can happen if
     * the dump was data only or if the user has used a toc list to exclude
     * all of the schema data. All we do is look for schema entries - if none
     * are found then we set the dataOnly flag.
     *
     * We could scan for wanted TABLE entries, but that is not the same as
     * dataOnly. At this stage, it seems unnecessary (6-Mar-2001).
     */
    if (!ropt->dataOnly)
    {
        int         impliedDataOnly = 1;
 
        for (te = AH->toc->next; te != AH->toc; te = te->next)
        {
            if ((te->reqs & REQ_SCHEMA) != 0)
            {                   /* It's schema, and it's wanted */
                impliedDataOnly = 0;
                break;
            }
        }
        if (impliedDataOnly)
        {
            ropt->dataOnly = impliedDataOnly;
            pg_log_info("implied data-only restore");
        }
    }
 
    /*
     * Setup the output file if necessary.
     */
    sav = SaveOutput(AH);
    if (ropt->filename || ropt->compression_spec.algorithm != PG_COMPRESSION_NONE)
        SetOutput(AH, ropt->filename, ropt->compression_spec);
 
    ahprintf(AH, "--\n-- PostgreSQL database dump\n--\n\n");
 
    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");
 
    if (AH->public.verbose)
        dumpTimestamp(AH, "Started on", AH->createDate);
 
    if (ropt->single_txn)
    {
        if (AH->connection)
            StartTransaction(AHX);
        else
            ahprintf(AH, "BEGIN;\n\n");
    }
 
    /*
     * Establish important parameter values right away.
     */
    _doSetFixedOutputState(AH);
 
    AH->stage = STAGE_PROCESSING;
 
    /*
     * Drop the items at the start, in reverse order
     */
    if (ropt->dropSchema)
    {
        for (te = AH->toc->prev; te != AH->toc; te = te->prev)
        {
            AH->currentTE = te;
 
            /*
             * In createDB mode, issue a DROP *only* for the database as a
             * whole.  Issuing drops against anything else would be wrong,
             * because at this point we're connected to the wrong database.
             * (The DATABASE PROPERTIES entry, if any, should be treated like
             * the DATABASE entry.)
             */
            if (ropt->createDB)
            {
                if (strcmp(te->desc, "DATABASE") != 0 &&
                    strcmp(te->desc, "DATABASE PROPERTIES") != 0)
                    continue;
            }
 
            /* Otherwise, drop anything that's selected and has a dropStmt */
            if (((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0) && te->dropStmt)
            {
                bool        not_allowed_in_txn = false;
 
                pg_log_info("dropping %s %s", te->desc, te->tag);
 
                /*
                 * In --transaction-size mode, we have to temporarily exit our
                 * transaction block to drop objects that can't be dropped
                 * within a transaction.
                 */
                if (ropt->txn_size > 0)
                {
                    if (strcmp(te->desc, "DATABASE") == 0 ||
                        strcmp(te->desc, "DATABASE PROPERTIES") == 0)
                    {
                        not_allowed_in_txn = true;
                        if (AH->connection)
                            CommitTransaction(AHX);
                        else
                            ahprintf(AH, "COMMIT;\n");
                    }
                }
 
                /* Select owner and schema as necessary */
                _becomeOwner(AH, te);
                _selectOutputSchema(AH, te->namespace);
 
                /*
                 * Now emit the DROP command, if the object has one.  Note we
                 * don't necessarily emit it verbatim; at this point we add an
                 * appropriate IF EXISTS clause, if the user requested it.
                 */
                if (strcmp(te->desc, "BLOB METADATA") == 0)
                {
                    /* We must generate the per-blob commands */
                    if (ropt->if_exists)
                        IssueCommandPerBlob(AH, te,
                                            "SELECT pg_catalog.lo_unlink(oid) "
                                            "FROM pg_catalog.pg_largeobject_metadata "
                                            "WHERE oid = '", "'");
                    else
                        IssueCommandPerBlob(AH, te,
                                            "SELECT pg_catalog.lo_unlink('",
                                            "')");
                }
                else if (*te->dropStmt != '\0')
                {
                    if (!ropt->if_exists ||
                        strncmp(te->dropStmt, "--", 2) == 0)
                    {
                        /*
                         * Without --if-exists, or if it's just a comment (as
                         * happens for the public schema), print the dropStmt
                         * as-is.
                         */
                        ahprintf(AH, "%s", te->dropStmt);
                    }
                    else
                    {
                        /*
                         * Inject an appropriate spelling of "if exists".  For
                         * old-style large objects, we have a routine that
                         * knows how to do it, without depending on
                         * te->dropStmt; use that.  For other objects we need
                         * to parse the command.
                         */
                        if (strcmp(te->desc, "BLOB") == 0)
                        {
                            DropLOIfExists(AH, te->catalogId.oid);
                        }
                        else
                        {
                            char       *dropStmt = pg_strdup(te->dropStmt);
                            char       *dropStmtOrig = dropStmt;
                            PQExpBuffer ftStmt = createPQExpBuffer();
 
                            /*
                             * Need to inject IF EXISTS clause after ALTER
                             * TABLE part in ALTER TABLE .. DROP statement
                             */
                            if (strncmp(dropStmt, "ALTER TABLE", 11) == 0)
                            {
                                appendPQExpBufferStr(ftStmt,
                                                     "ALTER TABLE IF EXISTS");
                                dropStmt = dropStmt + 11;
                            }
 
                            /*
                             * ALTER TABLE..ALTER COLUMN..DROP DEFAULT does
                             * not support the IF EXISTS clause, and therefore
                             * we simply emit the original command for DEFAULT
                             * objects (modulo the adjustment made above).
                             *
                             * Likewise, don't mess with DATABASE PROPERTIES.
                             *
                             * If we used CREATE OR REPLACE VIEW as a means of
                             * quasi-dropping an ON SELECT rule, that should
                             * be emitted unchanged as well.
                             *
                             * For other object types, we need to extract the
                             * first part of the DROP which includes the
                             * object type.  Most of the time this matches
                             * te->desc, so search for that; however for the
                             * different kinds of CONSTRAINTs, we know to
                             * search for hardcoded "DROP CONSTRAINT" instead.
                             */
                            if (strcmp(te->desc, "DEFAULT") == 0 ||
                                strcmp(te->desc, "DATABASE PROPERTIES") == 0 ||
                                strncmp(dropStmt, "CREATE OR REPLACE VIEW", 22) == 0)
                                appendPQExpBufferStr(ftStmt, dropStmt);
                            else
                            {
                                char        buffer[40];
                                char       *mark;
 
                                if (strcmp(te->desc, "CONSTRAINT") == 0 ||
                                    strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
                                    strcmp(te->desc, "FK CONSTRAINT") == 0)
                                    strcpy(buffer, "DROP CONSTRAINT");
                                else
                                    snprintf(buffer, sizeof(buffer), "DROP %s",
                                             te->desc);
 
                                mark = strstr(dropStmt, buffer);
 
                                if (mark)
                                {
                                    *mark = '\0';
                                    appendPQExpBuffer(ftStmt, "%s%s IF EXISTS%s",
                                                      dropStmt, buffer,
                                                      mark + strlen(buffer));
                                }
                                else
                                {
                                    /* complain and emit unmodified command */
                                    pg_log_warning("could not find where to insert IF EXISTS in statement \"%s\"",
                                                   dropStmtOrig);
                                    appendPQExpBufferStr(ftStmt, dropStmt);
                                }
                            }
 
                            ahprintf(AH, "%s", ftStmt->data);
 
                            destroyPQExpBuffer(ftStmt);
                            pg_free(dropStmtOrig);
                        }
                    }
                }
 
                /*
                 * In --transaction-size mode, re-establish the transaction
                 * block if needed; otherwise, commit after every N drops.
                 */
                if (ropt->txn_size > 0)
                {
                    if (not_allowed_in_txn)
                    {
                        if (AH->connection)
                            StartTransaction(AHX);
                        else
                            ahprintf(AH, "BEGIN;\n");
                        AH->txnCount = 0;
                    }
                    else if (++AH->txnCount >= ropt->txn_size)
                    {
                        if (AH->connection)
                        {
                            CommitTransaction(AHX);
                            StartTransaction(AHX);
                        }
                        else
                            ahprintf(AH, "COMMIT;\nBEGIN;\n");
                        AH->txnCount = 0;
                    }
                }
            }
        }
 
        /*
         * _selectOutputSchema may have set currSchema to reflect the effect
         * of a "SET search_path" command it emitted.  However, by now we may
         * have dropped that schema; or it might not have existed in the first
         * place.  In either case the effective value of search_path will not
         * be what we think.  Forcibly reset currSchema so that we will
         * re-establish the search_path setting when needed (after creating
         * the schema).
         *
         * If we treated users as pg_dump'able objects then we'd need to reset
         * currUser here too.
         */
        free(AH->currSchema);
        AH->currSchema = NULL;
    }
 
    if (parallel_mode)
    {
        /*
         * In parallel mode, turn control over to the parallel-restore logic.
         */
        ParallelState *pstate;
        TocEntry    pending_list;
 
        /* The archive format module may need some setup for this */
        if (AH->PrepParallelRestorePtr)
            AH->PrepParallelRestorePtr(AH);
 
        pending_list_header_init(&pending_list);
 
        /* This runs PRE_DATA items and then disconnects from the database */
        restore_toc_entries_prefork(AH, &pending_list);
        Assert(AH->connection == NULL);
 
        /* ParallelBackupStart() will actually fork the processes */
        pstate = ParallelBackupStart(AH);
        restore_toc_entries_parallel(AH, pstate, &pending_list);
        ParallelBackupEnd(AH, pstate);
 
        /* reconnect the leader and see if we missed something */
        restore_toc_entries_postfork(AH, &pending_list);
        Assert(AH->connection != NULL);
    }
    else
    {
        /*
         * In serial mode, process everything in three phases: normal items,
         * then ACLs, then post-ACL items.  We might be able to skip one or
         * both extra phases in some cases, eg data-only restores.
         */
        bool        haveACL = false;
        bool        havePostACL = false;
 
        for (te = AH->toc->next; te != AH->toc; te = te->next)
        {
            if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) == 0)
                continue;       /* ignore if not to be dumped at all */
 
            switch (_tocEntryRestorePass(te))
            {
                case RESTORE_PASS_MAIN:
                    (void) restore_toc_entry(AH, te, false);
                    break;
                case RESTORE_PASS_ACL:
                    haveACL = true;
                    break;
                case RESTORE_PASS_POST_ACL:
                    havePostACL = true;
                    break;
            }
        }
 
        if (haveACL)
        {
            for (te = AH->toc->next; te != AH->toc; te = te->next)
            {
                if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0 &&
                    _tocEntryRestorePass(te) == RESTORE_PASS_ACL)
                    (void) restore_toc_entry(AH, te, false);
            }
        }
 
        if (havePostACL)
        {
            for (te = AH->toc->next; te != AH->toc; te = te->next)
            {
                if ((te->reqs & (REQ_SCHEMA | REQ_DATA)) != 0 &&
                    _tocEntryRestorePass(te) == RESTORE_PASS_POST_ACL)
                    (void) restore_toc_entry(AH, te, false);
            }
        }
    }
 
    /*
     * Close out any persistent transaction we may have.  While these two
     * cases are started in different places, we can end both cases here.
     */
    if (ropt->single_txn || ropt->txn_size > 0)
    {
        if (AH->connection)
            CommitTransaction(AHX);
        else
            ahprintf(AH, "COMMIT;\n\n");
    }
 
    if (AH->public.verbose)
        dumpTimestamp(AH, "Completed on", time(NULL));
 
    ahprintf(AH, "--\n-- PostgreSQL database dump complete\n--\n\n");
 
    /*
     * Clean up & we're done.
     */
    AH->stage = STAGE_FINALIZING;
 
    if (ropt->filename || ropt->compression_spec.algorithm != PG_COMPRESSION_NONE)
        RestoreOutput(AH, sav);
 
    if (ropt->useDB)
        DisconnectDatabase(&AH->public);
}

References _becomeOwner(), _doSetFixedOutputState(), _selectOutputSchema(), _tocEntryRestorePass(), ahprintf(), pg_compress_specification::algorithm, appendPQExpBuffer(), appendPQExpBufferStr(), _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, Assert, buildTocEntryArrays(), _tocEntry::catalogId, _archiveHandle::ClonePtr, CommitTransaction(), _restoreOptions::compression_spec, _archiveHandle::compression_spec, ConnectDatabase(), _archiveHandle::connection, _restoreOptions::cparams, _archiveHandle::createDate, _restoreOptions::createDB, createPQExpBuffer(), _archiveHandle::currentTE, _archiveHandle::currSchema, PQExpBufferData::data, _restoreOptions::dataOnly, _tocEntry::desc, destroyPQExpBuffer(), DisconnectDatabase(), DropLOIfExists(), _restoreOptions::dropSchema, _tocEntry::dropStmt, dumpTimestamp(), errmsg(), _restoreOptions::filename, free, _tocEntry::hadDumper, _restoreOptions::if_exists, IssueCommandPerBlob(), K_VERS_1_3, K_VERS_1_8, Archive::maxRemoteVersion, Archive::minRemoteVersion, _tocEntry::next, _archiveHandle::noTocComments, Archive::numWorkers, CatalogId::oid, ParallelBackupEnd(), ParallelBackupStart(), pending_list_header_init(), PG_COMPRESSION_NONE, pg_fatal, pg_free(), pg_log_info, pg_log_warning, pg_strdup(), _archiveHandle::PrepParallelRestorePtr, _tocEntry::prev, _archiveHandle::PrintTocDataPtr, _archiveHandle::public, _archiveHandle::ReopenPtr, REQ_DATA, REQ_SCHEMA, _tocEntry::reqs, RESTORE_PASS_ACL, RESTORE_PASS_MAIN, RESTORE_PASS_POST_ACL, restore_toc_entries_parallel(), restore_toc_entries_postfork(), restore_toc_entries_prefork(), restore_toc_entry(), RestoreOutput(), Archive::ropt, SaveOutput(), SetOutput(), _restoreOptions::single_txn, snprintf, _archiveHandle::stage, STAGE_FINALIZING, STAGE_INITIALIZING, STAGE_PROCESSING, StartTransaction(), supports_compression(), _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocsByDumpId, _restoreOptions::txn_size, _archiveHandle::txnCount, _restoreOptions::useDB, Archive::verbose, and _archiveHandle::version.

Referenced by _CloseArchive(), and main().

SetArchiveOptions()

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

Definition at line 266 of file pg_backup_archiver.c.

{
    /* Caller can omit dump options, in which case we synthesize them */
    if (dopt == NULL && ropt != NULL)
        dopt = dumpOptionsFromRestoreOptions(ropt);
 
    /* Save options for later access */
    AH->dopt = dopt;
    AH->ropt = ropt;
}

References Archive::dopt, dumpOptionsFromRestoreOptions(), and Archive::ropt.

Referenced by _CloseArchive(), and main().

SortTocFromFile()

void SortTocFromFile

(

Archive *

AHX

)

Definition at line 1526 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    RestoreOptions *ropt = AH->public.ropt;
    FILE       *fh;
    StringInfoData linebuf;
 
    /* Allocate space for the 'wanted' array, and init it */
    ropt->idWanted = (bool *) pg_malloc0(sizeof(bool) * AH->maxDumpId);
 
    /* Setup the file */
    fh = fopen(ropt->tocFile, PG_BINARY_R);
    if (!fh)
        pg_fatal("could not open TOC file \"%s\": %m", ropt->tocFile);
 
    initStringInfo(&linebuf);
 
    while (pg_get_line_buf(fh, &linebuf))
    {
        char       *cmnt;
        char       *endptr;
        DumpId      id;
        TocEntry   *te;
 
        /* Truncate line at comment, if any */
        cmnt = strchr(linebuf.data, ';');
        if (cmnt != NULL)
        {
            cmnt[0] = '\0';
            linebuf.len = cmnt - linebuf.data;
        }
 
        /* Ignore if all blank */
        if (strspn(linebuf.data, " \t\r\n") == linebuf.len)
            continue;
 
        /* Get an ID, check it's valid and not already seen */
        id = strtol(linebuf.data, &endptr, 10);
        if (endptr == linebuf.data || id <= 0 || id > AH->maxDumpId ||
            ropt->idWanted[id - 1])
        {
            pg_log_warning("line ignored: %s", linebuf.data);
            continue;
        }
 
        /* Find TOC entry */
        te = getTocEntryByDumpId(AH, id);
        if (!te)
            pg_fatal("could not find entry for ID %d",
                     id);
 
        /* Mark it wanted */
        ropt->idWanted[id - 1] = true;
 
        /*
         * Move each item to the end of the list as it is selected, so that
         * they are placed in the desired order.  Any unwanted items will end
         * up at the front of the list, which may seem unintuitive but it's
         * what we need.  In an ordinary serial restore that makes no
         * difference, but in a parallel restore we need to mark unrestored
         * items' dependencies as satisfied before we start examining
         * restorable items.  Otherwise they could have surprising
         * side-effects on the order in which restorable items actually get
         * restored.
         */
        _moveBefore(AH->toc, te);
    }
 
    pg_free(linebuf.data);
 
    if (fclose(fh) != 0)
        pg_fatal("could not close TOC file: %m");
}

References _moveBefore(), StringInfoData::data, getTocEntryByDumpId(), _restoreOptions::idWanted, initStringInfo(), StringInfoData::len, _archiveHandle::maxDumpId, PG_BINARY_R, pg_fatal, pg_free(), pg_get_line_buf(), pg_log_warning, pg_malloc0(), _archiveHandle::public, Archive::ropt, _archiveHandle::toc, and _restoreOptions::tocFile.

Referenced by main().

StartLO()

int StartLO	(	Archive *	AHX,
		Oid	oid
	)

Definition at line 1371 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    if (!AH->StartLOPtr)
        pg_fatal("large-object output not supported in chosen format");
 
    AH->StartLOPtr(AH, AH->currToc, oid);
 
    return 1;
}

References _archiveHandle::currToc, pg_fatal, and _archiveHandle::StartLOPtr.

Referenced by dumpLOs().

WriteData()

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

Definition at line 1182 of file pg_backup_archiver.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    if (!AH->currToc)
        pg_fatal("internal error -- WriteData cannot be called outside the context of a DataDumper routine");
 
    AH->WriteDataPtr(AH, data, dLen);
}

References _archiveHandle::currToc, data, pg_fatal, and _archiveHandle::WriteDataPtr.

Referenced by archprintf(), archputs(), dumpLOs(), and dumpTableData_copy().