mirror of
https://github.com/postgres/postgres.git
synced 2025-05-01 01:04:50 +03:00
bb30d49a2a
- Fix view dumping SQL for V7.0 - Fix bug when getting view oid with long view names - Treat SEQUENCE SET TOC entries as data entries rather than schema entries. - Make allowance for data entries that did not have a data dumper routine (eg. SEQUENCE SET)
2221 lines
48 KiB
C
2221 lines
48 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* pg_backup_archiver.c
|
|
*
|
|
* Private implementation of the archiver routines.
|
|
*
|
|
* See the headers to pg_restore for more details.
|
|
*
|
|
* Copyright (c) 2000, Philip Warner
|
|
* Rights are granted to use this software in any way so long
|
|
* as this notice is not removed.
|
|
*
|
|
* The author is not responsible for loss or damages that may
|
|
* result from it's use.
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_backup_archiver.c,v 1.26 2001/05/12 01:03:59 pjw Exp $
|
|
*
|
|
* Modifications - 28-Jun-2000 - pjw@rhyme.com.au
|
|
*
|
|
* Initial version.
|
|
*
|
|
* Modifications - 31-Jul-2000 - pjw@rhyme.com.au (1.46, 1.47)
|
|
* Fixed version number initialization in _allocAH (pg_backup_archiver.c)
|
|
*
|
|
*
|
|
* Modifications - 30-Oct-2000 - pjw@rhyme.com.au
|
|
* Added {Start,End}RestoreBlobs to allow extended TX during BLOB restore.
|
|
*
|
|
* Modifications - 04-Jan-2001 - pjw@rhyme.com.au
|
|
* - strdup() the current user just in case it's deallocated from it's TOC
|
|
* entry. Should *never* happen, but that's what they said about the
|
|
* Titanic...
|
|
*
|
|
* - Check results of IO routines more carefully.
|
|
*
|
|
* Modifications - 27-Jan-2001 - pjw@rhyme.com.au
|
|
* - When dropping the schema, reconnect as owner of each object.
|
|
*
|
|
* Modifications - 6-Mar-2001 - pjw@rhyme.com.au
|
|
* - Only disable triggers in DataOnly (or implied data-only) restores.
|
|
*
|
|
* Modifications - 31-Mar-2001 - pjw@rhyme.com.au
|
|
*
|
|
* - Rudimentary support for dependencies in archives. Current implementation
|
|
* uses dependencies to modify the OID used in sorting TOC entries.
|
|
* This will NOT handle multi-level dependencies, but will manage simple
|
|
* relationships like UDTs & their functions.
|
|
*
|
|
* - Treat OIDs with more respect (avoid using ints, use macros for
|
|
* conversion & comparison).
|
|
*
|
|
* Modifications - 10-May-2001 - pjw@rhyme.com.au
|
|
* - Treat SEQUENCE SET TOC entries as data entries rather than schema
|
|
* entries.
|
|
* - Make allowance for data entries that did not have a data dumper
|
|
* routine (eg. SEQUENCE SET)
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "pg_backup.h"
|
|
#include "pg_backup_archiver.h"
|
|
#include "pg_backup_db.h"
|
|
|
|
#include <string.h>
|
|
#include <unistd.h> /* for dup */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "pqexpbuffer.h"
|
|
#include "libpq/libpq-fs.h"
|
|
|
|
static void _SortToc(ArchiveHandle *AH, TocSortCompareFn fn);
|
|
static int _tocSortCompareByOIDNum(const void *p1, const void *p2);
|
|
static int _tocSortCompareByIDNum(const void *p1, const void *p2);
|
|
static ArchiveHandle *_allocAH(const char *FileSpec, const ArchiveFormat fmt,
|
|
const int compression, ArchiveMode mode);
|
|
static int _printTocEntry(ArchiveHandle *AH, TocEntry *te, RestoreOptions *ropt, bool isData);
|
|
|
|
static void _reconnectAsOwner(ArchiveHandle *AH, const char *dbname, TocEntry *te);
|
|
static void _reconnectAsUser(ArchiveHandle *AH, const char *dbname, char *user);
|
|
|
|
static int _tocEntryRequired(TocEntry *te, RestoreOptions *ropt);
|
|
static void _disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te, RestoreOptions *ropt);
|
|
static void _enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te, RestoreOptions *ropt);
|
|
static TocEntry *_getTocEntry(ArchiveHandle *AH, int id);
|
|
static void _moveAfter(ArchiveHandle *AH, TocEntry *pos, TocEntry *te);
|
|
static void _moveBefore(ArchiveHandle *AH, TocEntry *pos, TocEntry *te);
|
|
static int _discoverArchiveFormat(ArchiveHandle *AH);
|
|
static void _fixupOidInfo(TocEntry *te);
|
|
static Oid _findMaxOID(const char *((*deps)[]));
|
|
|
|
static char *progname = "Archiver";
|
|
|
|
static void _die_horribly(ArchiveHandle *AH, const char *fmt, va_list ap);
|
|
|
|
static int _canRestoreBlobs(ArchiveHandle *AH);
|
|
static int _restoringToDB(ArchiveHandle *AH);
|
|
|
|
/*
|
|
* Wrapper functions.
|
|
*
|
|
* The objective it to make writing new formats and dumpers as simple
|
|
* as possible, if necessary at the expense of extra function calls etc.
|
|
*
|
|
*/
|
|
|
|
|
|
/* Create a new archive */
|
|
/* Public */
|
|
Archive *
|
|
CreateArchive(const char *FileSpec, const ArchiveFormat fmt,
|
|
const int compression)
|
|
|
|
{
|
|
ArchiveHandle *AH = _allocAH(FileSpec, fmt, compression, archModeWrite);
|
|
|
|
return (Archive *) AH;
|
|
}
|
|
|
|
/* Open an existing archive */
|
|
/* Public */
|
|
Archive *
|
|
OpenArchive(const char *FileSpec, const ArchiveFormat fmt)
|
|
{
|
|
ArchiveHandle *AH = _allocAH(FileSpec, fmt, 0, archModeRead);
|
|
|
|
return (Archive *) AH;
|
|
}
|
|
|
|
/* Public */
|
|
void
|
|
CloseArchive(Archive *AHX)
|
|
{
|
|
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)
|
|
die_horribly(AH, "%s: could not close the output file in CloseArchive\n", progname);
|
|
}
|
|
|
|
/* Public */
|
|
void
|
|
RestoreArchive(Archive *AHX, RestoreOptions *ropt)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
TocEntry *te = AH->toc->next;
|
|
int reqs;
|
|
OutputContext sav;
|
|
int impliedDataOnly;
|
|
bool defnDumped;
|
|
|
|
AH->ropt = ropt;
|
|
|
|
if (ropt->create && ropt->noReconnect)
|
|
die_horribly(AH, "%s: --create and --no-reconnect are incompatible options\n", progname);
|
|
|
|
/*
|
|
* If we're using a DB connection, then connect it.
|
|
*/
|
|
if (ropt->useDB)
|
|
{
|
|
ahlog(AH, 1, "Connecting to database for restore\n");
|
|
if (AH->version < K_VERS_1_3)
|
|
die_horribly(AH, "Direct database connections are not supported in pre-1.3 archives");
|
|
|
|
/* XXX Should get this from the archive */
|
|
AHX->minRemoteVersion = 070100;
|
|
AHX->maxRemoteVersion = 999999;
|
|
|
|
ConnectDatabase(AHX, ropt->dbname, ropt->pghost, ropt->pgport,
|
|
ropt->requirePassword, ropt->ignoreVersion);
|
|
|
|
/*
|
|
* If no superuser was specified then see if the current user will
|
|
* do...
|
|
*/
|
|
if (!ropt->superuser)
|
|
{
|
|
if (UserIsSuperuser(AH, ConnectedUser(AH)))
|
|
ropt->superuser = strdup(ConnectedUser(AH));
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Work out if we have an implied data-only retore. 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)
|
|
{
|
|
te = AH->toc->next;
|
|
impliedDataOnly = 1;
|
|
while (te != AH->toc)
|
|
{
|
|
reqs = _tocEntryRequired(te, ropt);
|
|
if ((reqs & 1) != 0)
|
|
{ /* It's schema, and it's wanted */
|
|
impliedDataOnly = 0;
|
|
break;
|
|
}
|
|
te = te->next;
|
|
}
|
|
if (impliedDataOnly)
|
|
{
|
|
ropt->dataOnly = impliedDataOnly;
|
|
ahlog(AH, 1, "Implied data-only restore\n");
|
|
}
|
|
}
|
|
|
|
if (!ropt->superuser)
|
|
fprintf(stderr, "\n%s: ******** WARNING ******** \n"
|
|
" Data restoration may fail since any defined triggers\n"
|
|
" can not be disabled (no superuser username specified).\n"
|
|
" This is only a problem for restoration into a database\n"
|
|
" with triggers already defined.\n\n", progname);
|
|
|
|
/*
|
|
* Setup the output file if necessary.
|
|
*/
|
|
if (ropt->filename || ropt->compression)
|
|
sav = SetOutput(AH, ropt->filename, ropt->compression);
|
|
|
|
ahprintf(AH, "--\n-- Selected TOC Entries:\n--\n");
|
|
|
|
/*
|
|
* Drop the items at the start, in reverse order
|
|
*/
|
|
if (ropt->dropSchema)
|
|
{
|
|
te = AH->toc->prev;
|
|
while (te != AH->toc)
|
|
{
|
|
reqs = _tocEntryRequired(te, ropt);
|
|
if (((reqs & 1) != 0) && te->dropStmt)
|
|
{ /* We want the schema */
|
|
ahlog(AH, 1, "Dropping %s %s\n", te->desc, te->name);
|
|
/* Reconnect if necessary */
|
|
_reconnectAsOwner(AH, "-", te);
|
|
/* Drop it */
|
|
ahprintf(AH, "%s", te->dropStmt);
|
|
}
|
|
te = te->prev;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now process each TOC entry
|
|
*/
|
|
te = AH->toc->next;
|
|
while (te != AH->toc)
|
|
{
|
|
|
|
/* Work out what, if anything, we want from this entry */
|
|
reqs = _tocEntryRequired(te, ropt);
|
|
|
|
/* Dump any relevant dump warnings to stderr */
|
|
if (!ropt->suppressDumpWarnings && strcmp(te->desc, "WARNING") == 0)
|
|
{
|
|
if (!ropt->dataOnly && te->defn != NULL && strlen(te->defn) != 0)
|
|
{
|
|
fprintf(stderr, "%s: Warning from original dump file:\n%s\n", progname, te->defn);
|
|
} else if (te->copyStmt != NULL && strlen(te->copyStmt) != 0)
|
|
{
|
|
fprintf(stderr, "%s: Warning from original dump file:\n%s\n", progname, te->copyStmt);
|
|
}
|
|
}
|
|
|
|
defnDumped = false;
|
|
|
|
if ((reqs & 1) != 0) /* We want the schema */
|
|
{
|
|
/* Reconnect if necessary */
|
|
_reconnectAsOwner(AH, "-", te);
|
|
|
|
ahlog(AH, 1, "Creating %s %s\n", te->desc, te->name);
|
|
_printTocEntry(AH, te, ropt, false);
|
|
defnDumped = true;
|
|
|
|
/* If we created a DB, connect to it... */
|
|
if (strcmp(te->desc, "DATABASE") == 0)
|
|
{
|
|
ahlog(AH, 1, "Connecting to new DB '%s' as %s\n", te->name, te->owner);
|
|
_reconnectAsUser(AH, te->name, te->owner);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we have a data component, then process it
|
|
*/
|
|
if ( (reqs & 2) != 0 )
|
|
{
|
|
/* hadDumper will be set if there is genuine data component for this
|
|
* node. Otherwise, we need to check the defn field for statements
|
|
* that need to be executed in data-only restores.
|
|
*/
|
|
if (te->hadDumper)
|
|
{
|
|
/*
|
|
* If we can output the data, then restore it.
|
|
*/
|
|
if (AH->PrintTocDataPtr !=NULL && (reqs & 2) != 0)
|
|
{
|
|
#ifndef HAVE_LIBZ
|
|
if (AH->compression != 0)
|
|
die_horribly(AH, "%s: Unable to restore data from a compressed archive\n",
|
|
progname);
|
|
#endif
|
|
|
|
_printTocEntry(AH, te, ropt, true);
|
|
|
|
/*
|
|
* Maybe we can't do BLOBS, so check if this node is for BLOBS
|
|
*/
|
|
if ((strcmp(te->desc, "BLOBS") == 0) && !_canRestoreBlobs(AH))
|
|
{
|
|
ahprintf(AH, "--\n-- SKIPPED \n--\n\n");
|
|
|
|
/*
|
|
* This is a bit nasty - we assume, for the moment, that
|
|
* if a custom output is used, then we don't want
|
|
* warnings.
|
|
*/
|
|
if (!AH->CustomOutPtr)
|
|
fprintf(stderr, "%s: WARNING - skipping BLOB restoration\n", progname);
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
_disableTriggersIfNecessary(AH, te, ropt);
|
|
|
|
/*
|
|
* Reconnect if necessary (_disableTriggers may have
|
|
* reconnected)
|
|
*/
|
|
_reconnectAsOwner(AH, "-", te);
|
|
|
|
ahlog(AH, 1, "Restoring data for %s \n", te->name);
|
|
|
|
/*
|
|
* If we have a copy statement, use it. As of V1.3, these
|
|
* are separate to allow easy import from withing a
|
|
* database connection. Pre 1.3 archives can not use DB
|
|
* connections and are sent to output only.
|
|
*
|
|
* For V1.3+, the table data MUST have a copy statement so
|
|
* that we can go into appropriate mode with libpq.
|
|
*/
|
|
if (te->copyStmt && strlen(te->copyStmt) > 0)
|
|
ahprintf(AH, te->copyStmt);
|
|
|
|
(*AH->PrintTocDataPtr) (AH, te, ropt);
|
|
|
|
_enableTriggersIfNecessary(AH, te, ropt);
|
|
}
|
|
}
|
|
} else if (!defnDumped) {
|
|
/* If we haven't already dumped the defn part, do so now */
|
|
ahlog(AH, 1, "Executing %s %s\n", te->desc, te->name);
|
|
_printTocEntry(AH, te, ropt, false);
|
|
}
|
|
}
|
|
te = te->next;
|
|
}
|
|
|
|
/*
|
|
* Now use blobs_xref (if used) to fixup any refs for tables that we
|
|
* loaded
|
|
*/
|
|
if (_canRestoreBlobs(AH) && AH->createdBlobXref)
|
|
{
|
|
/* NULL parameter means disable ALL user triggers */
|
|
_disableTriggersIfNecessary(AH, NULL, ropt);
|
|
|
|
te = AH->toc->next;
|
|
while (te != AH->toc)
|
|
{
|
|
|
|
/* Is it table data? */
|
|
if (strcmp(te->desc, "TABLE DATA") == 0)
|
|
{
|
|
|
|
ahlog(AH, 2, "Checking if we loaded %s\n", te->name);
|
|
|
|
reqs = _tocEntryRequired(te, ropt);
|
|
|
|
if ((reqs & 2) != 0) /* We loaded the data */
|
|
{
|
|
ahlog(AH, 1, "Fixing up BLOB ref for %s\n", te->name);
|
|
FixupBlobRefs(AH, te->name);
|
|
}
|
|
}
|
|
else
|
|
ahlog(AH, 2, "Ignoring BLOB xrefs for %s %s\n", te->desc, te->name);
|
|
|
|
te = te->next;
|
|
}
|
|
|
|
/* NULL parameter means enable ALL user triggers */
|
|
_enableTriggersIfNecessary(AH, NULL, ropt);
|
|
}
|
|
|
|
/*
|
|
* Clean up & we're done.
|
|
*/
|
|
if (ropt->filename)
|
|
ResetOutput(AH, sav);
|
|
|
|
if (ropt->useDB)
|
|
{
|
|
PQfinish(AH->connection);
|
|
AH->connection = NULL;
|
|
|
|
if (AH->blobConnection)
|
|
{
|
|
PQfinish(AH->blobConnection);
|
|
AH->blobConnection = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Allocate a new RestoreOptions block.
|
|
* This is mainly so we can initialize it, but also for future expansion,
|
|
*/
|
|
RestoreOptions *
|
|
NewRestoreOptions(void)
|
|
{
|
|
RestoreOptions *opts;
|
|
|
|
opts = (RestoreOptions *) calloc(1, sizeof(RestoreOptions));
|
|
|
|
opts->format = archUnknown;
|
|
opts->suppressDumpWarnings = false;
|
|
|
|
return opts;
|
|
}
|
|
|
|
static int
|
|
_restoringToDB(ArchiveHandle *AH)
|
|
{
|
|
return (AH->ropt->useDB && AH->connection);
|
|
}
|
|
|
|
static int
|
|
_canRestoreBlobs(ArchiveHandle *AH)
|
|
{
|
|
return _restoringToDB(AH);
|
|
}
|
|
|
|
static void
|
|
_disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te, RestoreOptions *ropt)
|
|
{
|
|
char *oldUser = NULL;
|
|
|
|
/* Can't do much if we're connected & don't have a superuser */
|
|
/* Also, don't bother with triggers unless a data-only retore. */
|
|
if (!ropt->dataOnly || (_restoringToDB(AH) && !ropt->superuser))
|
|
return;
|
|
|
|
/*
|
|
* Reconnect as superuser if possible, since they are the only ones
|
|
* who can update pg_class...
|
|
*/
|
|
if (ropt->superuser)
|
|
{
|
|
if (!_restoringToDB(AH) || !ConnectedUserIsSuperuser(AH))
|
|
{
|
|
|
|
/*
|
|
* If we're not allowing changes for ownership, then remember
|
|
* the user so we can change it back here. Otherwise, let
|
|
* _reconnectAsOwner do what it has to do.
|
|
*/
|
|
if (ropt->noOwner)
|
|
oldUser = strdup(ConnectedUser(AH));
|
|
_reconnectAsUser(AH, "-", ropt->superuser);
|
|
}
|
|
}
|
|
|
|
ahlog(AH, 1, "Disabling triggers\n");
|
|
|
|
/*
|
|
* Disable them. This is a hack. Needs to be done via an appropriate
|
|
* 'SET' command when one is available.
|
|
*/
|
|
ahprintf(AH, "-- Disable triggers\n");
|
|
|
|
/*
|
|
* Just update the AFFECTED table, if known.
|
|
*/
|
|
|
|
if (te && te->name && strlen(te->name) > 0)
|
|
ahprintf(AH, "UPDATE \"pg_class\" SET \"reltriggers\" = 0 WHERE \"relname\" = '%s';\n\n",
|
|
te->name);
|
|
else
|
|
ahprintf(AH, "UPDATE \"pg_class\" SET \"reltriggers\" = 0 WHERE \"relname\" !~ '^pg_';\n\n");
|
|
|
|
/*
|
|
* Restore the user connection from the start of this procedure if
|
|
* _reconnectAsOwner is disabled.
|
|
*/
|
|
if (ropt->noOwner && oldUser)
|
|
{
|
|
_reconnectAsUser(AH, "-", oldUser);
|
|
free(oldUser);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te, RestoreOptions *ropt)
|
|
{
|
|
char *oldUser = NULL;
|
|
|
|
/* Can't do much if we're connected & don't have a superuser */
|
|
/* Also, don't bother with triggers unless a data-only retore. */
|
|
if (!ropt->dataOnly || (_restoringToDB(AH) && !ropt->superuser))
|
|
return;
|
|
|
|
/*
|
|
* Reconnect as superuser if possible, since they are the only ones
|
|
* who can update pg_class...
|
|
*/
|
|
if (ropt->superuser)
|
|
{
|
|
if (!_restoringToDB(AH) || !ConnectedUserIsSuperuser(AH))
|
|
{
|
|
|
|
/*
|
|
* If we're not allowing changes for ownership, then remember
|
|
* the user so we can change it back here. Otherwise, let
|
|
* _reconnectAsOwner do what it has to do
|
|
*/
|
|
if (ropt->noOwner)
|
|
oldUser = strdup(ConnectedUser(AH));
|
|
|
|
_reconnectAsUser(AH, "-", ropt->superuser);
|
|
}
|
|
}
|
|
|
|
ahlog(AH, 1, "Enabling triggers\n");
|
|
|
|
/*
|
|
* Enable them. This is a hack. Needs to be done via an appropriate
|
|
* 'SET' command when one is available.
|
|
*/
|
|
ahprintf(AH, "-- Enable triggers\n");
|
|
if (te && te->name && strlen(te->name) > 0)
|
|
{
|
|
ahprintf(AH, "UPDATE pg_class SET reltriggers = "
|
|
"(SELECT count(*) FROM pg_trigger where pg_class.oid = tgrelid) "
|
|
"WHERE relname = '%s';\n\n",
|
|
te->name);
|
|
}
|
|
else
|
|
{
|
|
ahprintf(AH, "UPDATE \"pg_class\" SET \"reltriggers\" = "
|
|
"(SELECT count(*) FROM pg_trigger where pg_class.oid = tgrelid) "
|
|
"WHERE \"relname\" !~ '^pg_';\n\n");
|
|
}
|
|
|
|
/*
|
|
* Restore the user connection from the start of this procedure if
|
|
* _reconnectAsOwner is disabled.
|
|
*/
|
|
if (ropt->noOwner && oldUser)
|
|
{
|
|
_reconnectAsUser(AH, "-", oldUser);
|
|
free(oldUser);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This is a routine that is part of the dumper interface, hence the 'Archive*' parameter.
|
|
*/
|
|
|
|
/* Public */
|
|
int
|
|
WriteData(Archive *AHX, const void *data, int dLen)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
|
|
if (!AH->currToc)
|
|
die_horribly(AH, "%s: WriteData can not be called outside the context of "
|
|
"a DataDumper routine\n", progname);
|
|
|
|
return (*AH->WriteDataPtr) (AH, data, dLen);
|
|
}
|
|
|
|
/*
|
|
* Create a new TOC entry. The TOC was designed as a TOC, but is now the
|
|
* repository for all metadata. But the name has stuck.
|
|
*/
|
|
|
|
/* Public */
|
|
void
|
|
ArchiveEntry(Archive *AHX, const char *oid, const char *name,
|
|
const char *desc, const char *((*deps)[]), const char *defn,
|
|
const char *dropStmt, const char *copyStmt, const char *owner,
|
|
DataDumperPtr dumpFn, void *dumpArg)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
TocEntry *newToc;
|
|
|
|
AH->lastID++;
|
|
AH->tocCount++;
|
|
|
|
newToc = (TocEntry *) calloc(1, sizeof(TocEntry));
|
|
if (!newToc)
|
|
die_horribly(AH, "Archiver: unable to allocate memory for TOC entry\n");
|
|
|
|
newToc->prev = AH->toc->prev;
|
|
newToc->next = AH->toc;
|
|
AH->toc->prev->next = newToc;
|
|
AH->toc->prev = newToc;
|
|
|
|
newToc->id = AH->lastID;
|
|
|
|
newToc->name = strdup(name);
|
|
newToc->desc = strdup(desc);
|
|
|
|
newToc->oid = strdup(oid);
|
|
newToc->depOid = deps;
|
|
_fixupOidInfo(newToc);
|
|
|
|
|
|
newToc->defn = strdup(defn);
|
|
newToc->dropStmt = strdup(dropStmt);
|
|
newToc->copyStmt = copyStmt ? strdup(copyStmt) : NULL;
|
|
newToc->owner = strdup(owner);
|
|
newToc->printed = 0;
|
|
newToc->formatData = NULL;
|
|
newToc->dataDumper = dumpFn,
|
|
newToc->dataDumperArg = dumpArg;
|
|
|
|
newToc->hadDumper = dumpFn ? 1 : 0;
|
|
|
|
if (AH->ArchiveEntryPtr !=NULL)
|
|
(*AH->ArchiveEntryPtr) (AH, newToc);
|
|
|
|
/*
|
|
* printf("New toc owned by '%s', oid %d\n", newToc->owner,
|
|
* newToc->oidVal);
|
|
*/
|
|
}
|
|
|
|
/* Public */
|
|
void
|
|
PrintTOCSummary(Archive *AHX, RestoreOptions *ropt)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
TocEntry *te = AH->toc->next;
|
|
OutputContext sav;
|
|
char *fmtName;
|
|
|
|
if (ropt->filename)
|
|
sav = SetOutput(AH, ropt->filename, ropt->compression);
|
|
|
|
ahprintf(AH, ";\n; Archive created at %s", ctime(&AH->createDate));
|
|
ahprintf(AH, "; dbname: %s\n; TOC Entries: %d\n; Compression: %d\n",
|
|
AH->archdbname, AH->tocCount, AH->compression);
|
|
|
|
switch (AH->format)
|
|
{
|
|
case archFiles:
|
|
fmtName = "FILES";
|
|
break;
|
|
case archCustom:
|
|
fmtName = "CUSTOM";
|
|
break;
|
|
case archTar:
|
|
fmtName = "TAR";
|
|
break;
|
|
default:
|
|
fmtName = "UNKNOWN";
|
|
}
|
|
|
|
ahprintf(AH, "; Dump Version: %d.%d-%d\n", AH->vmaj, AH->vmin, AH->vrev);
|
|
ahprintf(AH, "; Format: %s\n;\n", fmtName);
|
|
|
|
ahprintf(AH, ";\n; Selected TOC Entries:\n;\n");
|
|
|
|
while (te != AH->toc)
|
|
{
|
|
if (_tocEntryRequired(te, ropt) != 0)
|
|
ahprintf(AH, "%d; %d %s %s %s\n", te->id, te->oidVal, te->desc, te->name, te->owner);
|
|
te = te->next;
|
|
}
|
|
|
|
if (ropt->filename)
|
|
ResetOutput(AH, sav);
|
|
}
|
|
|
|
/***********
|
|
* BLOB Archival
|
|
***********/
|
|
|
|
/* Called by a dumper to signal start of a BLOB */
|
|
int
|
|
StartBlob(Archive *AHX, Oid oid)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
|
|
if (!AH->StartBlobPtr)
|
|
die_horribly(AH, "%s: BLOB output not supported in chosen format\n", progname);
|
|
|
|
(*AH->StartBlobPtr) (AH, AH->currToc, oid);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Called by a dumper to signal end of a BLOB */
|
|
int
|
|
EndBlob(Archive *AHX, Oid oid)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
|
|
if (AH->EndBlobPtr)
|
|
(*AH->EndBlobPtr) (AH, AH->currToc, oid);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**********
|
|
* BLOB Restoration
|
|
**********/
|
|
|
|
/*
|
|
* Called by a format handler before any blobs are restored
|
|
*/
|
|
void
|
|
StartRestoreBlobs(ArchiveHandle *AH)
|
|
{
|
|
AH->blobCount = 0;
|
|
}
|
|
|
|
/*
|
|
* Called by a format handler after all blobs are restored
|
|
*/
|
|
void
|
|
EndRestoreBlobs(ArchiveHandle *AH)
|
|
{
|
|
if (AH->txActive)
|
|
{
|
|
ahlog(AH, 2, "Committing BLOB transactions\n");
|
|
CommitTransaction(AH);
|
|
}
|
|
|
|
if (AH->blobTxActive)
|
|
CommitTransactionXref(AH);
|
|
|
|
ahlog(AH, 1, "Restored %d BLOBs\n", AH->blobCount);
|
|
}
|
|
|
|
|
|
/*
|
|
* Called by a format handler to initiate restoration of a blob
|
|
*/
|
|
void
|
|
StartRestoreBlob(ArchiveHandle *AH, Oid oid)
|
|
{
|
|
int loOid;
|
|
|
|
AH->blobCount++;
|
|
|
|
if (!AH->createdBlobXref)
|
|
{
|
|
if (!AH->connection)
|
|
die_horribly(AH, "%s: can not restore BLOBs without a database connection", progname);
|
|
|
|
CreateBlobXrefTable(AH);
|
|
AH->createdBlobXref = 1;
|
|
}
|
|
|
|
/*
|
|
* Start long-running TXs if necessary
|
|
*/
|
|
if (!AH->txActive)
|
|
{
|
|
ahlog(AH, 2, "Starting BLOB transactions\n");
|
|
StartTransaction(AH);
|
|
}
|
|
if (!AH->blobTxActive)
|
|
StartTransactionXref(AH);
|
|
|
|
loOid = lo_creat(AH->connection, INV_READ | INV_WRITE);
|
|
if (loOid == 0)
|
|
die_horribly(AH, "%s: unable to create BLOB\n", progname);
|
|
|
|
ahlog(AH, 2, "Restoring BLOB oid %d as %d\n", oid, loOid);
|
|
|
|
InsertBlobXref(AH, oid, loOid);
|
|
|
|
AH->loFd = lo_open(AH->connection, loOid, INV_WRITE);
|
|
if (AH->loFd == -1)
|
|
die_horribly(AH, "%s: unable to open BLOB\n", progname);
|
|
|
|
AH->writingBlob = 1;
|
|
}
|
|
|
|
void
|
|
EndRestoreBlob(ArchiveHandle *AH, Oid oid)
|
|
{
|
|
lo_close(AH->connection, AH->loFd);
|
|
AH->writingBlob = 0;
|
|
|
|
/*
|
|
* Commit every BLOB_BATCH_SIZE blobs...
|
|
*/
|
|
if (((AH->blobCount / BLOB_BATCH_SIZE) * BLOB_BATCH_SIZE) == AH->blobCount)
|
|
{
|
|
ahlog(AH, 2, "Committing BLOB transactions\n");
|
|
CommitTransaction(AH);
|
|
CommitTransactionXref(AH);
|
|
}
|
|
}
|
|
|
|
/***********
|
|
* Sorting and Reordering
|
|
***********/
|
|
|
|
/*
|
|
* Move TOC entries of the specified type to the START of the TOC.
|
|
*/
|
|
|
|
/* Public */
|
|
void
|
|
MoveToStart(Archive *AHX, char *oType)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
TocEntry *te = AH->toc->next;
|
|
TocEntry *newTe;
|
|
|
|
while (te != AH->toc)
|
|
{
|
|
te->_moved = 0;
|
|
te = te->next;
|
|
}
|
|
|
|
te = AH->toc->prev;
|
|
while (te != AH->toc && !te->_moved)
|
|
{
|
|
newTe = te->prev;
|
|
if (strcmp(te->desc, oType) == 0)
|
|
_moveAfter(AH, AH->toc, te);
|
|
te = newTe;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Move TOC entries of the specified type to the end of the TOC.
|
|
*/
|
|
/* Public */
|
|
void
|
|
MoveToEnd(Archive *AHX, char *oType)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
TocEntry *te = AH->toc->next;
|
|
TocEntry *newTe;
|
|
|
|
while (te != AH->toc)
|
|
{
|
|
te->_moved = 0;
|
|
te = te->next;
|
|
}
|
|
|
|
te = AH->toc->next;
|
|
while (te != AH->toc && !te->_moved)
|
|
{
|
|
newTe = te->next;
|
|
if (strcmp(te->desc, oType) == 0)
|
|
_moveBefore(AH, AH->toc, te);
|
|
te = newTe;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sort TOC by OID
|
|
*/
|
|
/* Public */
|
|
void
|
|
SortTocByOID(Archive *AHX)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
|
|
_SortToc(AH, _tocSortCompareByOIDNum);
|
|
}
|
|
|
|
/*
|
|
* Sort TOC by ID
|
|
*/
|
|
/* Public */
|
|
void
|
|
SortTocByID(Archive *AHX)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
|
|
_SortToc(AH, _tocSortCompareByIDNum);
|
|
}
|
|
|
|
void
|
|
SortTocFromFile(Archive *AHX, RestoreOptions *ropt)
|
|
{
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
|
FILE *fh;
|
|
char buf[1024];
|
|
char *cmnt;
|
|
char *endptr;
|
|
int id;
|
|
TocEntry *te;
|
|
TocEntry *tePrev;
|
|
int i;
|
|
|
|
/* Allocate space for the 'wanted' array, and init it */
|
|
ropt->idWanted = (int *) malloc(sizeof(int) * AH->tocCount);
|
|
for (i = 0; i < AH->tocCount; i++)
|
|
ropt->idWanted[i] = 0;
|
|
|
|
ropt->limitToList = 1;
|
|
|
|
/* Mark all entries as 'not moved' */
|
|
te = AH->toc->next;
|
|
while (te != AH->toc)
|
|
{
|
|
te->_moved = 0;
|
|
te = te->next;
|
|
}
|
|
|
|
/* Set prev entry as head of list */
|
|
tePrev = AH->toc;
|
|
|
|
/* Setup the file */
|
|
fh = fopen(ropt->tocFile, PG_BINARY_R);
|
|
if (!fh)
|
|
die_horribly(AH, "%s: could not open TOC file\n", progname);
|
|
|
|
while (fgets(buf, 1024, fh) != NULL)
|
|
{
|
|
/* Find a comment */
|
|
cmnt = strchr(buf, ';');
|
|
if (cmnt == buf)
|
|
continue;
|
|
|
|
/* End string at comment */
|
|
if (cmnt != NULL)
|
|
cmnt[0] = '\0';
|
|
|
|
/* Skip if all spaces */
|
|
if (strspn(buf, " \t") == strlen(buf))
|
|
continue;
|
|
|
|
/* Get an ID */
|
|
id = strtol(buf, &endptr, 10);
|
|
if (endptr == buf)
|
|
{
|
|
fprintf(stderr, "%s: WARNING - line ignored: %s\n", progname, buf);
|
|
continue;
|
|
}
|
|
|
|
/* Find TOC entry */
|
|
te = _getTocEntry(AH, id);
|
|
if (!te)
|
|
die_horribly(AH, "%s: could not find entry for id %d\n", progname, id);
|
|
|
|
ropt->idWanted[id - 1] = 1;
|
|
|
|
_moveAfter(AH, tePrev, te);
|
|
tePrev = te;
|
|
}
|
|
|
|
if (fclose(fh) != 0)
|
|
die_horribly(AH, "%s: could not close TOC file\n", progname);
|
|
}
|
|
|
|
/**********************
|
|
* 'Convenience functions that look like standard IO functions
|
|
* for writing data when in dump mode.
|
|
**********************/
|
|
|
|
/* Public */
|
|
int
|
|
archputs(const char *s, Archive *AH)
|
|
{
|
|
return WriteData(AH, s, strlen(s));
|
|
}
|
|
|
|
/* Public */
|
|
int
|
|
archputc(const char c, Archive *AH)
|
|
{
|
|
return WriteData(AH, &c, 1);
|
|
}
|
|
|
|
/* Public */
|
|
int
|
|
archprintf(Archive *AH, const char *fmt,...)
|
|
{
|
|
char *p = NULL;
|
|
va_list ap;
|
|
int bSize = strlen(fmt) + 256;
|
|
int cnt = -1;
|
|
|
|
/*
|
|
* This is paranoid: deal with the possibility that vsnprintf is
|
|
* willing to ignore trailing null
|
|
*/
|
|
|
|
/*
|
|
* or returns > 0 even if string does not fit. It may be the case that
|
|
* it returns cnt = bufsize
|
|
*/
|
|
while (cnt < 0 || cnt >= (bSize - 1))
|
|
{
|
|
if (p != NULL)
|
|
free(p);
|
|
bSize *= 2;
|
|
p = (char *) malloc(bSize);
|
|
if (p == NULL)
|
|
exit_horribly(AH, "%s: could not allocate buffer for archprintf\n", progname);
|
|
va_start(ap, fmt);
|
|
cnt = vsnprintf(p, bSize, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
WriteData(AH, p, cnt);
|
|
free(p);
|
|
return cnt;
|
|
}
|
|
|
|
|
|
/*******************************
|
|
* Stuff below here should be 'private' to the archiver routines
|
|
*******************************/
|
|
|
|
OutputContext
|
|
SetOutput(ArchiveHandle *AH, char *filename, int compression)
|
|
{
|
|
OutputContext sav;
|
|
|
|
#ifdef HAVE_LIBZ
|
|
char fmode[10];
|
|
|
|
#endif
|
|
int fn = 0;
|
|
|
|
/* Replace the AH output file handle */
|
|
sav.OF = AH->OF;
|
|
sav.gzOut = AH->gzOut;
|
|
|
|
if (filename)
|
|
fn = 0;
|
|
else if (AH->FH)
|
|
fn = fileno(AH->FH);
|
|
else if (AH->fSpec)
|
|
{
|
|
fn = 0;
|
|
filename = AH->fSpec;
|
|
}
|
|
else
|
|
fn = fileno(stdout);
|
|
|
|
/* If compression explicitly requested, use gzopen */
|
|
#ifdef HAVE_LIBZ
|
|
if (compression != 0)
|
|
{
|
|
sprintf(fmode, "wb%d", compression);
|
|
if (fn)
|
|
{
|
|
AH->OF = gzdopen(dup(fn), fmode); /* Don't use PG_BINARY_x
|
|
* since this is zlib */
|
|
}
|
|
else
|
|
AH->OF = gzopen(filename, fmode);
|
|
AH->gzOut = 1;
|
|
}
|
|
else
|
|
{ /* Use fopen */
|
|
#endif
|
|
if (fn)
|
|
AH->OF = fdopen(dup(fn), PG_BINARY_W);
|
|
else
|
|
AH->OF = fopen(filename, PG_BINARY_W);
|
|
AH->gzOut = 0;
|
|
#ifdef HAVE_LIBZ
|
|
}
|
|
#endif
|
|
|
|
if (!AH->OF)
|
|
die_horribly(AH, "%s: could not set output\n", progname);
|
|
|
|
return sav;
|
|
}
|
|
|
|
void
|
|
ResetOutput(ArchiveHandle *AH, OutputContext sav)
|
|
{
|
|
int res;
|
|
|
|
if (AH->gzOut)
|
|
res = GZCLOSE(AH->OF);
|
|
else
|
|
res = fclose(AH->OF);
|
|
|
|
if (res != 0)
|
|
die_horribly(AH, "%s: could not reset the output file\n", progname);
|
|
|
|
AH->gzOut = sav.gzOut;
|
|
AH->OF = sav.OF;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Print formatted text to the output file (usually stdout).
|
|
*/
|
|
int
|
|
ahprintf(ArchiveHandle *AH, const char *fmt,...)
|
|
{
|
|
char *p = NULL;
|
|
va_list ap;
|
|
int bSize = strlen(fmt) + 256; /* Should be enough */
|
|
int cnt = -1;
|
|
|
|
/*
|
|
* This is paranoid: deal with the possibility that vsnprintf is
|
|
* willing to ignore trailing null
|
|
*/
|
|
|
|
/*
|
|
* or returns > 0 even if string does not fit. It may be the case that
|
|
* it returns cnt = bufsize
|
|
*/
|
|
while (cnt < 0 || cnt >= (bSize - 1))
|
|
{
|
|
if (p != NULL)
|
|
free(p);
|
|
bSize *= 2;
|
|
p = (char *) malloc(bSize);
|
|
if (p == NULL)
|
|
die_horribly(AH, "%s: could not allocate buffer for ahprintf\n", progname);
|
|
va_start(ap, fmt);
|
|
cnt = vsnprintf(p, bSize, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
ahwrite(p, 1, cnt, AH);
|
|
free(p);
|
|
return cnt;
|
|
}
|
|
|
|
void
|
|
ahlog(ArchiveHandle *AH, int level, const char *fmt,...)
|
|
{
|
|
va_list ap;
|
|
|
|
if (AH->debugLevel < level && (!AH->public.verbose || level > 1))
|
|
return;
|
|
|
|
va_start(ap, fmt);
|
|
vfprintf(stderr, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
/*
|
|
* Single place for logic which says 'We are restoring to a direct DB connection'.
|
|
*/
|
|
int
|
|
RestoringToDB(ArchiveHandle *AH)
|
|
{
|
|
return (AH->ropt && AH->ropt->useDB && AH->connection);
|
|
}
|
|
|
|
/*
|
|
* Write buffer to the output file (usually stdout). This is user for
|
|
* outputting 'restore' scripts etc. It is even possible for an archive
|
|
* format to create a custom output routine to 'fake' a restore if it
|
|
* wants to generate a script (see TAR output).
|
|
*/
|
|
int
|
|
ahwrite(const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)
|
|
{
|
|
int res;
|
|
|
|
if (AH->writingBlob)
|
|
{
|
|
res = lo_write(AH->connection, AH->loFd, (void *) ptr, size * nmemb);
|
|
ahlog(AH, 5, "Wrote %d bytes of BLOB data (result = %d)\n", size * nmemb, res);
|
|
if (res < size * nmemb)
|
|
die_horribly(AH, "%s: could not write to large object (result = %d, expected %d)\n",
|
|
progname, res, size * nmemb);
|
|
|
|
return res;
|
|
}
|
|
else if (AH->gzOut)
|
|
{
|
|
res = GZWRITE((void *) ptr, size, nmemb, AH->OF);
|
|
if (res != (nmemb * size))
|
|
die_horribly(AH, "%s: could not write to archive\n", progname);
|
|
return res;
|
|
}
|
|
else if (AH->CustomOutPtr)
|
|
{
|
|
res = AH->CustomOutPtr (AH, ptr, size * nmemb);
|
|
|
|
if (res != (nmemb * size))
|
|
die_horribly(AH, "%s: could not write to custom output routine\n", progname);
|
|
return res;
|
|
}
|
|
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))
|
|
return ExecuteSqlCommandBuf(AH, (void *) ptr, size * nmemb); /* Always 1, currently */
|
|
else
|
|
{
|
|
res = fwrite((void *) ptr, size, nmemb, AH->OF);
|
|
if (res != nmemb)
|
|
die_horribly(AH, "%s: could not write to output file (%d != %d)\n", progname, res, nmemb);
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Common exit code */
|
|
static void
|
|
_die_horribly(ArchiveHandle *AH, const char *fmt, va_list ap)
|
|
{
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
if (AH)
|
|
if (AH->connection)
|
|
PQfinish(AH->connection);
|
|
if (AH->blobConnection)
|
|
PQfinish(AH->blobConnection);
|
|
|
|
exit(1);
|
|
}
|
|
|
|
/* External use */
|
|
void
|
|
exit_horribly(Archive *AH, const char *fmt,...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
_die_horribly((ArchiveHandle *) AH, fmt, ap);
|
|
}
|
|
|
|
/* Archiver use (just different arg declaration) */
|
|
void
|
|
die_horribly(ArchiveHandle *AH, const char *fmt,...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
_die_horribly(AH, fmt, ap);
|
|
}
|
|
|
|
|
|
static void
|
|
_moveAfter(ArchiveHandle *AH, TocEntry *pos, TocEntry *te)
|
|
{
|
|
te->prev->next = te->next;
|
|
te->next->prev = te->prev;
|
|
|
|
te->prev = pos;
|
|
te->next = pos->next;
|
|
|
|
pos->next->prev = te;
|
|
pos->next = te;
|
|
|
|
te->_moved = 1;
|
|
}
|
|
|
|
static void
|
|
_moveBefore(ArchiveHandle *AH, TocEntry *pos, TocEntry *te)
|
|
{
|
|
te->prev->next = te->next;
|
|
te->next->prev = te->prev;
|
|
|
|
te->prev = pos->prev;
|
|
te->next = pos;
|
|
pos->prev->next = te;
|
|
pos->prev = te;
|
|
|
|
te->_moved = 1;
|
|
}
|
|
|
|
static TocEntry *
|
|
_getTocEntry(ArchiveHandle *AH, int id)
|
|
{
|
|
TocEntry *te;
|
|
|
|
te = AH->toc->next;
|
|
while (te != AH->toc)
|
|
{
|
|
if (te->id == id)
|
|
return te;
|
|
te = te->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
TocIDRequired(ArchiveHandle *AH, int id, RestoreOptions *ropt)
|
|
{
|
|
TocEntry *te = _getTocEntry(AH, id);
|
|
|
|
if (!te)
|
|
return 0;
|
|
|
|
return _tocEntryRequired(te, ropt);
|
|
}
|
|
|
|
int
|
|
WriteInt(ArchiveHandle *AH, int i)
|
|
{
|
|
int b;
|
|
|
|
/*
|
|
* This is a bit yucky, but I don't want to make the binary format
|
|
* very dependant on representation, and not knowing much about it, I
|
|
* write out a sign byte. If you change this, don't forget to change
|
|
* the file version #, and modify readInt to read the new format AS
|
|
* WELL AS the old formats.
|
|
*/
|
|
|
|
/* SIGN byte */
|
|
if (i < 0)
|
|
{
|
|
(*AH->WriteBytePtr) (AH, 1);
|
|
i = -i;
|
|
}
|
|
else
|
|
(*AH->WriteBytePtr) (AH, 0);
|
|
|
|
for (b = 0; b < AH->intSize; b++)
|
|
{
|
|
(*AH->WriteBytePtr) (AH, i & 0xFF);
|
|
i = i / 256;
|
|
}
|
|
|
|
return AH->intSize + 1;
|
|
}
|
|
|
|
int
|
|
ReadInt(ArchiveHandle *AH)
|
|
{
|
|
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;
|
|
}
|
|
|
|
int
|
|
WriteStr(ArchiveHandle *AH, const char *c)
|
|
{
|
|
int res;
|
|
|
|
if (c)
|
|
{
|
|
res = WriteInt(AH, strlen(c));
|
|
res += (*AH->WriteBufPtr) (AH, c, strlen(c));
|
|
}
|
|
else
|
|
res = WriteInt(AH, -1);
|
|
|
|
return res;
|
|
}
|
|
|
|
char *
|
|
ReadStr(ArchiveHandle *AH)
|
|
{
|
|
char *buf;
|
|
int l;
|
|
|
|
l = ReadInt(AH);
|
|
if (l == -1)
|
|
buf = NULL;
|
|
else
|
|
{
|
|
buf = (char *) malloc(l + 1);
|
|
if (!buf)
|
|
die_horribly(AH, "%s: Unable to allocate sufficient memory in ReadStr - " "requested %d (0x%x) bytes\n", progname, l, l);
|
|
|
|
(*AH->ReadBufPtr) (AH, (void *) buf, l);
|
|
buf[l] = '\0';
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static int
|
|
_discoverArchiveFormat(ArchiveHandle *AH)
|
|
{
|
|
FILE *fh;
|
|
char sig[6]; /* More than enough */
|
|
int cnt;
|
|
int wantClose = 0;
|
|
|
|
/*
|
|
* fprintf(stderr, "%s: Attempting to ascertain archive format\n",
|
|
* progname);
|
|
*/
|
|
|
|
if (AH->lookahead)
|
|
free(AH->lookahead);
|
|
|
|
AH->lookaheadSize = 512;
|
|
AH->lookahead = calloc(1, 512);
|
|
AH->lookaheadLen = 0;
|
|
AH->lookaheadPos = 0;
|
|
|
|
if (AH->fSpec)
|
|
{
|
|
wantClose = 1;
|
|
fh = fopen(AH->fSpec, PG_BINARY_R);
|
|
}
|
|
else
|
|
fh = stdin;
|
|
|
|
if (!fh)
|
|
die_horribly(AH, "Archiver: could not open input file\n");
|
|
|
|
cnt = fread(sig, 1, 5, fh);
|
|
|
|
if (cnt != 5)
|
|
die_horribly(AH, "%s: input file is too short, or is unreadable (read %d, expected 5)\n",
|
|
progname, cnt);
|
|
|
|
/* Save it, just in case we need it later */
|
|
strncpy(&AH->lookahead[0], sig, 5);
|
|
AH->lookaheadLen = 5;
|
|
|
|
if (strncmp(sig, "PGDMP", 5) == 0)
|
|
{
|
|
AH->vmaj = fgetc(fh);
|
|
AH->vmin = fgetc(fh);
|
|
|
|
/* Save these too... */
|
|
AH->lookahead[AH->lookaheadLen++] = AH->vmaj;
|
|
AH->lookahead[AH->lookaheadLen++] = AH->vmin;
|
|
|
|
/* Check header version; varies from V1.0 */
|
|
if (AH->vmaj > 1 || ((AH->vmaj == 1) && (AH->vmin > 0))) /* Version > 1.0 */
|
|
{
|
|
AH->vrev = fgetc(fh);
|
|
AH->lookahead[AH->lookaheadLen++] = AH->vrev;
|
|
}
|
|
else
|
|
AH->vrev = 0;
|
|
|
|
AH->intSize = fgetc(fh);
|
|
AH->lookahead[AH->lookaheadLen++] = AH->intSize;
|
|
|
|
AH->format = fgetc(fh);
|
|
AH->lookahead[AH->lookaheadLen++] = AH->format;
|
|
|
|
/* Make a convenient integer <maj><min><rev>00 */
|
|
AH->version = ((AH->vmaj * 256 + AH->vmin) * 256 + AH->vrev) * 256 + 0;
|
|
}
|
|
else
|
|
{
|
|
|
|
/*
|
|
* *Maybe* we have a tar archive format file... So, read first 512
|
|
* byte header...
|
|
*/
|
|
cnt = fread(&AH->lookahead[AH->lookaheadLen], 1, 512 - AH->lookaheadLen, fh);
|
|
AH->lookaheadLen += cnt;
|
|
|
|
if (AH->lookaheadLen != 512)
|
|
die_horribly(AH, "%s: input file does not appear to be a valid archive (too short?)\n",
|
|
progname);
|
|
|
|
if (!isValidTarHeader(AH->lookahead))
|
|
die_horribly(AH, "%s: input file does not appear to be a valid archive\n", progname);
|
|
|
|
AH->format = archTar;
|
|
}
|
|
|
|
/* If we can't seek, then mark the header as read */
|
|
if (fseek(fh, 0, SEEK_SET) != 0)
|
|
{
|
|
|
|
/*
|
|
* NOTE: Formats that use the looahead buffer can unset this in
|
|
* their Init routine.
|
|
*/
|
|
AH->readHeader = 1;
|
|
}
|
|
else
|
|
AH->lookaheadLen = 0; /* Don't bother since we've reset the file */
|
|
|
|
/*
|
|
* fprintf(stderr, "%s: read %d bytes into lookahead buffer\n",
|
|
* progname, AH->lookaheadLen);
|
|
*/
|
|
|
|
/* Close the file */
|
|
if (wantClose)
|
|
if (fclose(fh) != 0)
|
|
die_horribly(AH, "%s: could not close the input file after reading header\n", progname);
|
|
|
|
return AH->format;
|
|
}
|
|
|
|
|
|
/*
|
|
* Allocate an archive handle
|
|
*/
|
|
static ArchiveHandle *
|
|
_allocAH(const char *FileSpec, const ArchiveFormat fmt,
|
|
const int compression, ArchiveMode mode)
|
|
{
|
|
ArchiveHandle *AH;
|
|
|
|
/*
|
|
* fprintf(stderr, "%s: allocating AH for %s, format %d\n", progname,
|
|
* FileSpec, fmt);
|
|
*/
|
|
|
|
AH = (ArchiveHandle *) calloc(1, sizeof(ArchiveHandle));
|
|
if (!AH)
|
|
die_horribly(AH, "Archiver: Could not allocate archive handle\n");
|
|
|
|
AH->vmaj = K_VERS_MAJOR;
|
|
AH->vmin = K_VERS_MINOR;
|
|
AH->vrev = K_VERS_REV;
|
|
|
|
AH->createDate = time(NULL);
|
|
|
|
AH->intSize = sizeof(int);
|
|
AH->lastID = 0;
|
|
if (FileSpec)
|
|
{
|
|
AH->fSpec = strdup(FileSpec);
|
|
|
|
/*
|
|
* Not used; maybe later....
|
|
*
|
|
* AH->workDir = strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
|
|
* i--) if (AH->workDir[i-1] == '/')
|
|
*/
|
|
}
|
|
else
|
|
AH->fSpec = NULL;
|
|
|
|
AH->currUser = strdup(""); /* So it's valid, but we can free() it
|
|
* later if necessary */
|
|
|
|
AH->toc = (TocEntry *) calloc(1, sizeof(TocEntry));
|
|
if (!AH->toc)
|
|
die_horribly(AH, "Archiver: Could not allocate TOC header\n");
|
|
|
|
AH->toc->next = AH->toc;
|
|
AH->toc->prev = AH->toc;
|
|
|
|
AH->mode = mode;
|
|
AH->compression = compression;
|
|
|
|
AH->pgCopyBuf = createPQExpBuffer();
|
|
AH->sqlBuf = createPQExpBuffer();
|
|
|
|
/* Open stdout with no compression for AH output handle */
|
|
AH->gzOut = 0;
|
|
AH->OF = stdout;
|
|
|
|
/*
|
|
* fprintf(stderr, "%s: archive format is %d\n", progname, fmt);
|
|
*/
|
|
|
|
if (fmt == archUnknown)
|
|
AH->format = _discoverArchiveFormat(AH);
|
|
else
|
|
AH->format = fmt;
|
|
|
|
switch (AH->format)
|
|
{
|
|
|
|
case archCustom:
|
|
InitArchiveFmt_Custom(AH);
|
|
break;
|
|
|
|
case archFiles:
|
|
InitArchiveFmt_Files(AH);
|
|
break;
|
|
|
|
case archNull:
|
|
InitArchiveFmt_Null(AH);
|
|
break;
|
|
|
|
case archTar:
|
|
InitArchiveFmt_Tar(AH);
|
|
break;
|
|
|
|
default:
|
|
die_horribly(AH, "Archiver: Unrecognized file format '%d'\n", fmt);
|
|
}
|
|
|
|
return AH;
|
|
}
|
|
|
|
|
|
void
|
|
WriteDataChunks(ArchiveHandle *AH)
|
|
{
|
|
TocEntry *te = AH->toc->next;
|
|
StartDataPtr startPtr;
|
|
EndDataPtr endPtr;
|
|
|
|
while (te != AH->toc)
|
|
{
|
|
if (te->dataDumper != NULL)
|
|
{
|
|
AH->currToc = te;
|
|
/* printf("Writing data for %d (%x)\n", te->id, te); */
|
|
|
|
if (strcmp(te->desc, "BLOBS") == 0)
|
|
{
|
|
startPtr = AH->StartBlobsPtr;
|
|
endPtr = AH->EndBlobsPtr;
|
|
}
|
|
else
|
|
{
|
|
startPtr = AH->StartDataPtr;
|
|
endPtr = AH->EndDataPtr;
|
|
}
|
|
|
|
if (startPtr != NULL)
|
|
(*startPtr) (AH, te);
|
|
|
|
/*
|
|
* printf("Dumper arg for %d is %x\n", te->id,
|
|
* te->dataDumperArg);
|
|
*/
|
|
|
|
/*
|
|
* The user-provided DataDumper routine needs to call
|
|
* AH->WriteData
|
|
*/
|
|
(*te->dataDumper) ((Archive *) AH, te->oid, te->dataDumperArg);
|
|
|
|
if (endPtr != NULL)
|
|
(*endPtr) (AH, te);
|
|
AH->currToc = NULL;
|
|
}
|
|
te = te->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
WriteToc(ArchiveHandle *AH)
|
|
{
|
|
TocEntry *te = AH->toc->next;
|
|
const char *dep;
|
|
int i;
|
|
|
|
/* printf("%d TOC Entries to save\n", AH->tocCount); */
|
|
|
|
WriteInt(AH, AH->tocCount);
|
|
while (te != AH->toc)
|
|
{
|
|
WriteInt(AH, te->id);
|
|
WriteInt(AH, te->dataDumper ? 1 : 0);
|
|
WriteStr(AH, te->oid);
|
|
|
|
WriteStr(AH, te->name);
|
|
WriteStr(AH, te->desc);
|
|
WriteStr(AH, te->defn);
|
|
WriteStr(AH, te->dropStmt);
|
|
WriteStr(AH, te->copyStmt);
|
|
WriteStr(AH, te->owner);
|
|
|
|
/* Dump list of dependencies */
|
|
if (te->depOid != NULL)
|
|
{
|
|
i = 0;
|
|
while( (dep = (*te->depOid)[i++]) != NULL)
|
|
{
|
|
WriteStr(AH, dep);
|
|
}
|
|
}
|
|
WriteStr(AH, NULL); /* Terminate List */
|
|
|
|
if (AH->WriteExtraTocPtr)
|
|
(*AH->WriteExtraTocPtr) (AH, te);
|
|
te = te->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
ReadToc(ArchiveHandle *AH)
|
|
{
|
|
int i;
|
|
char *((*deps)[]);
|
|
int depIdx;
|
|
int depSize;
|
|
|
|
TocEntry *te = AH->toc->next;
|
|
|
|
AH->tocCount = ReadInt(AH);
|
|
|
|
for (i = 0; i < AH->tocCount; i++)
|
|
{
|
|
|
|
te = (TocEntry *) calloc(1, sizeof(TocEntry));
|
|
te->id = ReadInt(AH);
|
|
|
|
/* Sanity check */
|
|
if (te->id <= 0 || te->id > AH->tocCount)
|
|
die_horribly(AH, "Archiver: failed sanity check (bad entry id) - perhaps a corrupt TOC\n");
|
|
|
|
te->hadDumper = ReadInt(AH);
|
|
te->oid = ReadStr(AH);
|
|
te->oidVal = atooid(te->oid);
|
|
|
|
te->name = ReadStr(AH);
|
|
te->desc = ReadStr(AH);
|
|
te->defn = ReadStr(AH);
|
|
te->dropStmt = ReadStr(AH);
|
|
|
|
if (AH->version >= K_VERS_1_3)
|
|
te->copyStmt = ReadStr(AH);
|
|
|
|
te->owner = ReadStr(AH);
|
|
|
|
/* Read TOC entry dependencies */
|
|
if (AH->version >= K_VERS_1_5)
|
|
{
|
|
depSize = 100;
|
|
deps = malloc(sizeof(char*) * depSize);
|
|
depIdx = 0;
|
|
do
|
|
{
|
|
if (depIdx > depSize)
|
|
{
|
|
depSize *= 2;
|
|
deps = realloc(deps, sizeof(char*) * depSize);
|
|
}
|
|
(*deps)[depIdx] = ReadStr(AH);
|
|
/*
|
|
* if ((*deps)[depIdx])
|
|
* fprintf(stderr, "Read Dependency for %s -> %s\n", te->name, (*deps)[depIdx]);
|
|
*/
|
|
} while ( (*deps)[depIdx++] != NULL);
|
|
|
|
if (depIdx > 1) /* We have a non-null entry */
|
|
{
|
|
/* Trim it */
|
|
te->depOid = realloc(deps, sizeof(char*) * depIdx);
|
|
} else { /* No deps */
|
|
te->depOid = NULL;
|
|
}
|
|
} else {
|
|
te->depOid = NULL;
|
|
}
|
|
|
|
/* Set maxOidVal etc for use in sorting */
|
|
_fixupOidInfo(te);
|
|
|
|
if (AH->ReadExtraTocPtr)
|
|
(*AH->ReadExtraTocPtr) (AH, te);
|
|
|
|
ahlog(AH, 3, "Read TOC entry %d (id %d) for %s %s\n", i, te->id, te->desc, te->name);
|
|
|
|
te->prev = AH->toc->prev;
|
|
AH->toc->prev->next = te;
|
|
AH->toc->prev = te;
|
|
te->next = AH->toc;
|
|
}
|
|
}
|
|
|
|
static int
|
|
_tocEntryRequired(TocEntry *te, RestoreOptions *ropt)
|
|
{
|
|
int res = 3; /* Schema = 1, Data = 2, Both = 3 */
|
|
|
|
/* If it's an ACL, maybe ignore it */
|
|
if (ropt->aclsSkip && strcmp(te->desc, "ACL") == 0)
|
|
return 0;
|
|
|
|
if (!ropt->create && strcmp(te->desc, "DATABASE") == 0)
|
|
return 0;
|
|
|
|
/* Check if tablename only is wanted */
|
|
if (ropt->selTypes)
|
|
{
|
|
if ((strcmp(te->desc, "TABLE") == 0) || (strcmp(te->desc, "TABLE DATA") == 0))
|
|
{
|
|
if (!ropt->selTable)
|
|
return 0;
|
|
if (ropt->tableNames && strcmp(ropt->tableNames, te->name) != 0)
|
|
return 0;
|
|
}
|
|
else if (strcmp(te->desc, "INDEX") == 0)
|
|
{
|
|
if (!ropt->selIndex)
|
|
return 0;
|
|
if (ropt->indexNames && strcmp(ropt->indexNames, te->name) != 0)
|
|
return 0;
|
|
}
|
|
else if (strcmp(te->desc, "FUNCTION") == 0)
|
|
{
|
|
if (!ropt->selFunction)
|
|
return 0;
|
|
if (ropt->functionNames && strcmp(ropt->functionNames, te->name) != 0)
|
|
return 0;
|
|
}
|
|
else if (strcmp(te->desc, "TRIGGER") == 0)
|
|
{
|
|
if (!ropt->selTrigger)
|
|
return 0;
|
|
if (ropt->triggerNames && strcmp(ropt->triggerNames, te->name) != 0)
|
|
return 0;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/* Special Case: If 'SEQUENCE SET' then it is considered a data entry */
|
|
if (strcmp(te->desc, "SEQUENCE SET") == 0)
|
|
res = res & 2;
|
|
|
|
/* Mask it if we only want schema */
|
|
if (ropt->schemaOnly)
|
|
res = res & 1;
|
|
|
|
/* Mask it we only want data */
|
|
if (ropt->dataOnly)
|
|
res = res & 2;
|
|
|
|
/* Mask it if we don't have a schema contribition */
|
|
if (!te->defn || strlen(te->defn) == 0)
|
|
res = res & 2;
|
|
|
|
/* Finally, if we used a list, limit based on that as well */
|
|
if (ropt->limitToList && !ropt->idWanted[te->id - 1])
|
|
return 0;
|
|
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
_reconnectAsUser(ArchiveHandle *AH, const char *dbname, char *user)
|
|
{
|
|
if (AH->ropt && AH->ropt->noReconnect)
|
|
return;
|
|
|
|
if (user && strlen(user) != 0
|
|
&& ((strcmp(AH->currUser, user) != 0) || (strcmp(dbname, "-") != 0)))
|
|
{
|
|
if (RestoringToDB(AH))
|
|
ReconnectDatabase(AH, dbname, user);
|
|
else
|
|
ahprintf(AH, "\\connect %s %s\n", dbname, user);
|
|
if (AH->currUser)
|
|
free(AH->currUser);
|
|
|
|
AH->currUser = strdup(user);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_reconnectAsOwner(ArchiveHandle *AH, const char *dbname, TocEntry *te)
|
|
{
|
|
if (AH->ropt && AH->ropt->noOwner)
|
|
return;
|
|
|
|
_reconnectAsUser(AH, dbname, te->owner);
|
|
}
|
|
|
|
static int
|
|
_printTocEntry(ArchiveHandle *AH, TocEntry *te, RestoreOptions *ropt, bool isData)
|
|
{
|
|
char *pfx;
|
|
|
|
if (isData)
|
|
{
|
|
pfx = "Data for ";
|
|
} else {
|
|
pfx = "";
|
|
}
|
|
|
|
ahprintf(AH, "--\n-- %sTOC Entry ID %d (OID %s)\n--\n-- Name: %s Type: %s Owner: %s\n",
|
|
pfx, te->id, te->oid, te->name, te->desc, te->owner);
|
|
if (AH->PrintExtraTocPtr !=NULL)
|
|
(*AH->PrintExtraTocPtr) (AH, te);
|
|
ahprintf(AH, "--\n\n");
|
|
|
|
ahprintf(AH, "%s\n", te->defn);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
WriteHead(ArchiveHandle *AH)
|
|
{
|
|
struct tm crtm;
|
|
|
|
(*AH->WriteBufPtr) (AH, "PGDMP", 5); /* Magic code */
|
|
(*AH->WriteBytePtr) (AH, AH->vmaj);
|
|
(*AH->WriteBytePtr) (AH, AH->vmin);
|
|
(*AH->WriteBytePtr) (AH, AH->vrev);
|
|
(*AH->WriteBytePtr) (AH, AH->intSize);
|
|
(*AH->WriteBytePtr) (AH, AH->format);
|
|
|
|
#ifndef HAVE_LIBZ
|
|
if (AH->compression != 0)
|
|
fprintf(stderr, "%s: WARNING - requested compression not available in this installation - "
|
|
"archive will be uncompressed \n", progname);
|
|
|
|
AH->compression = 0;
|
|
|
|
#endif
|
|
|
|
WriteInt(AH, AH->compression);
|
|
|
|
crtm = *localtime(&AH->createDate);
|
|
WriteInt(AH, crtm.tm_sec);
|
|
WriteInt(AH, crtm.tm_min);
|
|
WriteInt(AH, crtm.tm_hour);
|
|
WriteInt(AH, crtm.tm_mday);
|
|
WriteInt(AH, crtm.tm_mon);
|
|
WriteInt(AH, crtm.tm_year);
|
|
WriteInt(AH, crtm.tm_isdst);
|
|
WriteStr(AH, AH->dbname);
|
|
}
|
|
|
|
void
|
|
ReadHead(ArchiveHandle *AH)
|
|
{
|
|
char tmpMag[7];
|
|
int fmt;
|
|
struct tm crtm;
|
|
|
|
/* If we haven't already read the header... */
|
|
if (!AH->readHeader)
|
|
{
|
|
|
|
(*AH->ReadBufPtr) (AH, tmpMag, 5);
|
|
|
|
if (strncmp(tmpMag, "PGDMP", 5) != 0)
|
|
die_horribly(AH, "Archiver: Did not fing magic PGDMP in file header\n");
|
|
|
|
AH->vmaj = (*AH->ReadBytePtr) (AH);
|
|
AH->vmin = (*AH->ReadBytePtr) (AH);
|
|
|
|
if (AH->vmaj > 1 || ((AH->vmaj == 1) && (AH->vmin > 0))) /* Version > 1.0 */
|
|
AH->vrev = (*AH->ReadBytePtr) (AH);
|
|
else
|
|
AH->vrev = 0;
|
|
|
|
AH->version = ((AH->vmaj * 256 + AH->vmin) * 256 + AH->vrev) * 256 + 0;
|
|
|
|
|
|
if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
|
|
die_horribly(AH, "%s: unsupported version (%d.%d) in file header\n",
|
|
progname, AH->vmaj, AH->vmin);
|
|
|
|
AH->intSize = (*AH->ReadBytePtr) (AH);
|
|
if (AH->intSize > 32)
|
|
die_horribly(AH, "Archiver: sanity check on integer size (%d) failes\n", AH->intSize);
|
|
|
|
if (AH->intSize > sizeof(int))
|
|
fprintf(stderr, "\n%s: WARNING - archive was made on a machine with larger integers, "
|
|
"some operations may fail\n", progname);
|
|
|
|
fmt = (*AH->ReadBytePtr) (AH);
|
|
|
|
if (AH->format != fmt)
|
|
die_horribly(AH, "%s: expected format (%d) differs from format found in file (%d)\n",
|
|
progname, 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)
|
|
fprintf(stderr, "%s: WARNING - archive is compressed - any data will not be available\n",
|
|
progname);
|
|
#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)
|
|
fprintf(stderr, "%s: WARNING - bad creation date in header\n", progname);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
_SortToc(ArchiveHandle *AH, TocSortCompareFn fn)
|
|
{
|
|
TocEntry **tea;
|
|
TocEntry *te;
|
|
int i;
|
|
|
|
/* Allocate an array for quicksort (TOC size + head & foot) */
|
|
tea = (TocEntry **) malloc(sizeof(TocEntry *) * (AH->tocCount + 2));
|
|
|
|
/* Build array of toc entries, including header at start and end */
|
|
te = AH->toc;
|
|
for (i = 0; i <= AH->tocCount + 1; i++)
|
|
{
|
|
|
|
/*
|
|
* printf("%d: %x (%x, %x) - %d\n", i, te, te->prev, te->next,
|
|
* te->oidVal);
|
|
*/
|
|
tea[i] = te;
|
|
te = te->next;
|
|
}
|
|
|
|
/* Sort it, but ignore the header entries */
|
|
qsort(&(tea[1]), AH->tocCount, sizeof(TocEntry *), fn);
|
|
|
|
/* Rebuild list: this works becuase we have headers at each end */
|
|
for (i = 1; i <= AH->tocCount; i++)
|
|
{
|
|
tea[i]->next = tea[i + 1];
|
|
tea[i]->prev = tea[i - 1];
|
|
}
|
|
|
|
|
|
te = AH->toc;
|
|
for (i = 0; i <= AH->tocCount + 1; i++)
|
|
{
|
|
|
|
/*
|
|
* printf("%d: %x (%x, %x) - %d\n", i, te, te->prev, te->next,
|
|
* te->oidVal);
|
|
*/
|
|
te = te->next;
|
|
}
|
|
|
|
|
|
AH->toc->next = tea[1];
|
|
AH->toc->prev = tea[AH->tocCount];
|
|
}
|
|
|
|
static int
|
|
_tocSortCompareByOIDNum(const void *p1, const void *p2)
|
|
{
|
|
TocEntry *te1 = *(TocEntry **) p1;
|
|
TocEntry *te2 = *(TocEntry **) p2;
|
|
Oid id1 = te1->maxOidVal;
|
|
Oid id2 = te2->maxOidVal;
|
|
int cmpval;
|
|
|
|
/* printf("Comparing %d to %d\n", id1, id2); */
|
|
|
|
cmpval = oidcmp(id1, id2);
|
|
|
|
/* If we have a deterministic answer, return it. */
|
|
if (cmpval != 0)
|
|
return cmpval;
|
|
|
|
/* More comparisons required */
|
|
if ( oideq(id1, te1->maxDepOidVal) ) /* maxOid1 came from deps */
|
|
{
|
|
if ( oideq(id2, te2->maxDepOidVal) ) /* maxOid2 also came from deps */
|
|
{
|
|
cmpval = oidcmp(te1->oidVal, te2->oidVal); /* Just compare base OIDs */
|
|
}
|
|
else /* MaxOid2 was entry OID */
|
|
{
|
|
return 1; /* entry1 > entry2 */
|
|
};
|
|
}
|
|
else /* must have oideq(id1, te1->oidVal) => maxOid1 = Oid1 */
|
|
{
|
|
if ( oideq(id2, te2->maxDepOidVal) ) /* maxOid2 came from deps */
|
|
{
|
|
return -1; /* entry1 < entry2 */
|
|
}
|
|
else /* MaxOid2 was entry OID - deps don't matter */
|
|
{
|
|
cmpval = 0;
|
|
};
|
|
};
|
|
|
|
/* If we get here, then we've done another comparison
|
|
* Once again, a 0 result means we require even more
|
|
*/
|
|
if (cmpval != 0)
|
|
return cmpval;
|
|
|
|
/* Entire OID details match, so use ID number (ie. original pg_dump order) */
|
|
return _tocSortCompareByIDNum(te1, te2);
|
|
}
|
|
|
|
static int
|
|
_tocSortCompareByIDNum(const void *p1, const void *p2)
|
|
{
|
|
TocEntry *te1 = *(TocEntry **) p1;
|
|
TocEntry *te2 = *(TocEntry **) p2;
|
|
int id1 = te1->id;
|
|
int id2 = te2->id;
|
|
|
|
/* printf("Comparing %d to %d\n", id1, id2); */
|
|
|
|
if (id1 < id2)
|
|
return -1;
|
|
else if (id1 > id2)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Assuming Oid and depOid are set, work out the various
|
|
* Oid values used in sorting.
|
|
*/
|
|
static void
|
|
_fixupOidInfo(TocEntry *te)
|
|
{
|
|
te->oidVal = atooid(te->oid);
|
|
te->maxDepOidVal = _findMaxOID(te->depOid);
|
|
|
|
/* For the purpose of sorting, find the max OID. */
|
|
if (oidcmp(te->oidVal, te->maxDepOidVal) >= 0)
|
|
te->maxOidVal = te->oidVal;
|
|
else
|
|
te->maxOidVal = te->maxDepOidVal;
|
|
}
|
|
|
|
/*
|
|
* Find the max OID value for a given list of string Oid values
|
|
*/
|
|
static Oid
|
|
_findMaxOID(const char *((*deps)[]))
|
|
{
|
|
const char *dep;
|
|
int i;
|
|
Oid maxOid = (Oid)0;
|
|
Oid currOid;
|
|
|
|
if (!deps)
|
|
return maxOid;
|
|
|
|
i = 0;
|
|
while( (dep = (*deps)[i++]) != NULL)
|
|
{
|
|
currOid = atooid(dep);
|
|
if (oidcmp(maxOid, currOid) < 0)
|
|
maxOid = currOid;
|
|
}
|
|
|
|
return maxOid;
|
|
}
|
|
|
|
/*
|
|
* Maybe I can use this somewhere...
|
|
*
|
|
*create table pgdump_blob_path(p text);
|
|
*insert into pgdump_blob_path values('/home/pjw/work/postgresql-cvs/pgsql/src/bin/pg_dump_140');
|
|
*
|
|
*insert into dump_blob_xref select 12345,lo_import(p || '/q.q') from pgdump_blob_path;
|
|
*/
|