/*------------------------------------------------------------------------- * * 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 its use . * * * IDENTIFICATION * src / bin / pg_dump / pg_backup_archiver . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres_fe.h" #include <ctype.h>#include <fcntl.h>#include <unistd.h>#include <sys/stat.h>#include <sys/wait.h>#ifdef WIN32#include <io.h>#endif #include "catalog/pg_class_d.h" #include "common/string.h" #include "compress_io.h" #include "dumputils.h" #include "fe_utils/string_utils.h" #include "lib/binaryheap.h" #include "lib/stringinfo.h" #include "libpq/libpq-fs.h" #include "parallel.h" #include "pg_backup_archiver.h" #include "pg_backup_db.h" #include "pg_backup_utils.h" #include "pgtar.h" #define TEXT_DUMP_HEADER "--\n-- PostgreSQL database dump\n--\n\n" #define TEXT_DUMPALL_HEADER "--\n-- PostgreSQL database cluster dump\n--\n\n" #define TOC_PREFIX_NONE "" #define TOC_PREFIX_DATA "Data for " #define TOC_PREFIX_STATS "Statistics for " static ArchiveHandle *_allocAH(const char *FileSpec, const ArchiveFormat fmt,const pg_compress_specification compression_spec,bool dosync, ArchiveMode mode,static void _getObjectDescription(PQExpBuffer buf, const TocEntry *te);static void _printTocEntry(ArchiveHandle *AH, TocEntry *te, const char *pfx);static void _doSetFixedOutputState(ArchiveHandle *AH);static void _doSetSessionAuth(ArchiveHandle *AH, const char *user);static void _reconnectToDB(ArchiveHandle *AH, const char *dbname);static void _becomeUser(ArchiveHandle *AH, const char *user);static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tableam);static void _printTableAccessMethodNoStorage(ArchiveHandle *AH,static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);static int _tocEntryRequired(TocEntry *te, teSection curSection, ArchiveHandle *AH);static RestorePass _tocEntryRestorePass(TocEntry *te);static bool _tocEntryIsACL(TocEntry *te);static void _disableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te);static void _enableTriggersIfNecessary(ArchiveHandle *AH, TocEntry *te);static bool is_load_via_partition_root(TocEntry *te);static void buildTocEntryArrays(ArchiveHandle *AH);static void _moveBefore(TocEntry *pos, TocEntry *te);static int _discoverArchiveFormat(ArchiveHandle *AH);static int RestoringToDB(ArchiveHandle *AH);static void dump_lo_buf(ArchiveHandle *AH);static void dumpTimestamp(ArchiveHandle *AH, const char *msg, time_t tim);static void SetOutput(ArchiveHandle *AH, const char *filename,const pg_compress_specification compression_spec);static CompressFileHandle *SaveOutput(ArchiveHandle *AH);static void RestoreOutput(ArchiveHandle *AH, CompressFileHandle *savedOutput);static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel);static void restore_toc_entries_prefork(ArchiveHandle *AH,static void restore_toc_entries_parallel(ArchiveHandle *AH,static void restore_toc_entries_postfork(ArchiveHandle *AH,static void pending_list_header_init(TocEntry *l);static void pending_list_append(TocEntry *l, TocEntry *te);static void pending_list_remove(TocEntry *te);static int TocEntrySizeCompareQsort(const void *p1, const void *p2);static int TocEntrySizeCompareBinaryheap(void *p1, void *p2, void *arg);static void move_to_ready_heap(TocEntry *pending_list,static TocEntry *pop_next_work_item(binaryheap *ready_heap,static void mark_dump_job_done(ArchiveHandle *AH,int status,void *callback_data);static void mark_restore_job_done(ArchiveHandle *AH,int status,void *callback_data);static void fix_dependencies(ArchiveHandle *AH);static bool has_lock_conflicts(TocEntry *te1, TocEntry *te2);static void repoint_table_dependencies(ArchiveHandle *AH);static void identify_locking_dependencies(ArchiveHandle *AH, TocEntry *te);static void reduce_dependencies(ArchiveHandle *AH, TocEntry *te,static void mark_create_done(ArchiveHandle *AH, TocEntry *te);static void inhibit_data_for_failed_table(ArchiveHandle *AH, TocEntry *te);static void StrictNamesCheck(RestoreOptions *ropt);/* * Allocate a new DumpOptions block containing all default values . void )sizeof (DumpOptions));return opts;/* * Initialize a DumpOptions struct to all default values void 0 , sizeof (DumpOptions));/* set any fields that shouldn't default to zeroes */ true ;true ;true ;false ;/* * Create a freshly allocated DumpOptions with options equivalent to those * found in the given RestoreOptions . /* this is the inverse of what's at the end of pg_dump.c's main() */ L;return dopt;/* * Wrapper functions . * * The objective is to make writing new formats and dumpers as simple * as possible , if necessary at the expense of extra function calls etc . * /* * The dump worker setup needs lots of knowledge of the internals of pg_dump , * so it ' s defined in pg_dump . c and passed into OpenArchive . The restore worker * setup doesn ' t need to know anything much , so it ' s defined here . static void /* Create a new archive */ /* Public */ const char *FileSpec, const ArchiveFormat fmt,const pg_compress_specification compression_spec,bool dosync, ArchiveMode mode,return (Archive *) AH;/* Open an existing archive */ /* Public */ const char *FileSpec, const ArchiveFormat fmt)0 };true ,return (Archive *) AH;/* Public */ void /* Close the output */ 0 ;if (!EndCompressFileHandle(AH->OF))"could not close output file: %m" );/* Public */ void /* Caller can omit dump options, in which case we synthesize them */ if (dopt == NULL && ropt != NULL)/* Save options for later access */ /* Public */ void public .ropt;/* Decide which TOC entries will be dumped/restored, and mark them */ 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)"archive items not in correct section order" );break ;case SECTION_DATA:if (curSection == SECTION_POST_DATA)"archive items not in correct section order" );break ;case SECTION_POST_DATA:/* ok no matter which section we were in */ break ;default :"unexpected section code %d" ,int ) te->section);break ;if (te->section != SECTION_NONE)/* Enforce strict names checking */ if (ropt->strict_names)/* Public */ void public .ropt;bool parallel_mode;/* * If we ' re going to do parallel restore , there are some restrictions . 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)"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)"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 . /* * 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)"cannot restore from compressed archive (%s)" ,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)/* * If we ' re using a DB connection , then connect it . if (ropt->useDB)"connecting to database for restore" );if (AH->version < K_VERS_1_3)"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 . 0 ;9999999 ;false );/* * If we ' re talking to the DB directly , don ' t send comments since they * obscure SQL when displaying errors 1 ;/* * Work out if we have an implied schema - less restore . This can happen if * the dump excluded the schema or 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 unset the dumpSchema flag . * * We could scan for wanted TABLE entries , but that is not the same as * data - only . At this stage , it seems unnecessary ( 6 - Mar - 2001 ) . if (ropt->dumpSchema)bool no_schema_found = true ;for (te = AH->toc->next; te != AH->toc; te = te->next)if ((te->reqs & REQ_SCHEMA) != 0 )false ;break ;if (no_schema_found)false ;"implied no-schema restore" );/* * Setup the output file if necessary . if (ropt->filename || ropt->compression_spec.algorithm != PG_COMPRESSION_NONE)"--\n-- PostgreSQL database dump\n--\n\n" );/* * If generating plain - text output , enter restricted mode to block any * unexpected psql meta - commands . A malicious source might try to inject * a variety of things via bogus responses to queries . While we cannot * prevent such sources from affecting the destination at restore time , we * can block psql meta - commands so that the client machine that runs psql * with the dump output remains unaffected . if (ropt->restrict_key)"\\restrict %s\n\n" , ropt->restrict_key);if (AH->archiveRemoteVersion)"-- Dumped from database version %s\n" ,if (AH->archiveDumpVersion)"-- Dumped by pg_dump version %s\n" ,"\n" );if (AH->public .verbose)"Started on" , AH->createDate);if (ropt->single_txn)if (AH->connection)else "BEGIN;\n\n" );/* * Establish important parameter values right away . /* * Drop the items at the start , in reverse order if (ropt->dropSchema)for (te = AH->toc->prev; te != AH->toc; te = te->prev)/* * 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 &&"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 ;"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 ||"DATABASE PROPERTIES" ) == 0 )true ;if (AH->connection)else "COMMIT;\n" );/* Select owner and schema as necessary */ 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)"SELECT pg_catalog.lo_unlink(oid) " "FROM pg_catalog.pg_largeobject_metadata " "WHERE oid = '" , "'" );else "SELECT pg_catalog.lo_unlink('" ,"')" );else if (*te->dropStmt != '\0' )if (!ropt->if_exists ||"--" , 2 ) == 0 )/* * Without - - if - exists , or if it ' s just a comment ( as * happens for the public schema ) , print the dropStmt * as - is . "%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 )else char *dropStmt = pg_strdup(te->dropStmt);char *dropStmtOrig = dropStmt;/* * Need to inject IF EXISTS clause after ALTER * TABLE part in ALTER TABLE . . DROP statement if (strncmp(dropStmt, "ALTER TABLE" , 11 ) == 0 )"ALTER TABLE IF EXISTS" );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 ||"DATABASE PROPERTIES" ) == 0 ||"CREATE OR REPLACE VIEW" , 22 ) == 0 )else char buffer[40 ];char *mark;if (strcmp(te->desc, "CONSTRAINT" ) == 0 ||"CHECK CONSTRAINT" ) == 0 ||"FK CONSTRAINT" ) == 0 )"DROP CONSTRAINT" );else sizeof (buffer), "DROP %s" ,if (mark)'\0' ;"%s%s IF EXISTS%s" ,else /* complain and emit unmodified command */ "could not find where to insert IF EXISTS in statement \" %s\"" ,"%s" , ftStmt->data);/* * 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)else "BEGIN;\n" );0 ;else if (++AH->txnCount >= ropt->txn_size)if (AH->connection)else "COMMIT;\nBEGIN;\n" );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 . if (parallel_mode)/* * In parallel mode , turn control over to the parallel - restore logic . /* The archive format module may need some setup for this */ if (AH->PrepParallelRestorePtr)/* This runs PRE_DATA items and then disconnects from the database */ /* ParallelBackupStart() will actually fork the processes */ /* reconnect the leader and see if we missed something */ 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 | REQ_STATS)) == 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:true ;break ;case RESTORE_PASS_POST_ACL:true ;break ;if (haveACL)for (te = AH->toc->next; te != AH->toc; te = te->next)if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_STATS)) != 0 &&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 | REQ_STATS)) != 0 &&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)else "COMMIT;\n\n" );if (AH->public .verbose)"Completed on" , time(NULL));"--\n-- PostgreSQL database dump complete\n--\n\n" );/* * If generating plain - text output , exit restricted mode at the very end * of the script . This is not pro forma ; in particular , pg_dumpall * requires this when transitioning from one database to another . if (ropt->restrict_key)"\\unrestrict %s\n\n" , ropt->restrict_key);/* * Clean up & we ' re done . if (ropt->filename || ropt->compression_spec.algorithm != PG_COMPRESSION_NONE)if (ropt->useDB)public );/* * Restore a single TOC item . Used in both parallel and non - parallel restore ; * is_parallel is true if we are in a worker child process . * * Returns 0 normally , but WORKER_CREATE_DONE or WORKER_INHIBIT_DATA if * the parallel parent has to make the corresponding status update . static int bool is_parallel)public .ropt;int status = WORKER_OK;int reqs;bool defnDumped;/* Dump any relevant dump warnings to stderr */ if (!ropt->suppressDumpWarnings && strcmp(te->desc, "WARNING" ) == 0 )if (ropt->dumpSchema && te->defn != NULL && strlen(te->defn) != 0 )"warning from original dump file: %s" , te->defn);else if (te->copyStmt != NULL && strlen(te->copyStmt) != 0 )"warning from original dump file: %s" , te->copyStmt);/* Work out what, if anything, we want from this entry */ false ;/* * If it has a schema component that we want , then process that if ((reqs & REQ_SCHEMA) != 0 )bool object_is_db = false ;/* * In - - transaction - size mode , must exit our transaction block to * create a database or set its properties . if (strcmp(te->desc, "DATABASE" ) == 0 ||"DATABASE PROPERTIES" ) == 0 )true ;if (ropt->txn_size > 0 )if (AH->connection)public );else "COMMIT;\n\n" );/* Show namespace in log message if available */ if (te->namespace )"creating %s \" %s.%s\"" ,namespace , te->tag);else "creating %s \" %s\"" ,true ;if (strcmp(te->desc, "TABLE" ) == 0 )if (AH->lastErrorTE == te)/* * We failed to create the table . If * - - no - data - for - failed - tables was given , mark the * corresponding TABLE DATA to be ignored . * * In the parallel case this must be done in the parent , so we * just set the return value . if (ropt->noDataForFailedTables)if (is_parallel)else else /* * We created the table successfully . Mark the corresponding * TABLE DATA for possible truncation . * * In the parallel case this must be done in the parent , so we * just set the return value . if (is_parallel)else /* * If we created a DB , connect to it . Also , if we changed DB * properties , reconnect to ensure that relevant GUC settings are * applied to our session . ( That also restarts the transaction block * in - - transaction - size mode . ) if (object_is_db)"connecting to new database \" %s\"" , te->tag);/* * If it has a data component that we want , then process that if ((reqs & REQ_DATA) != 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)if (strcmp(te->desc, "BLOBS" ) == 0 ||"BLOB COMMENTS" ) == 0 )"processing %s" , te->desc);"pg_catalog" );/* Send BLOB COMMENTS data to ExecuteSimpleCommands() */ if (strcmp(te->desc, "BLOB COMMENTS" ) == 0 )else bool use_truncate;/* Select owner and schema as necessary */ namespace );"processing data for table \" %s.%s\"" ,namespace , te->tag);/* * In parallel restore , if we created the table earlier in * this run ( so that we know it is empty ) and we are not * restoring a load - via - partition - root data item then we * wrap the COPY in a transaction and precede it with a * TRUNCATE . If wal_level is set to minimal this prevents * WAL - logging the COPY . This obtains a speedup similar * to that from using single_txn mode in non - parallel * restores . * * We mustn ' t do this for load - via - partition - root cases * because some data might get moved across partition * boundaries , risking deadlock and / or loss of previously * loaded data . ( We assume that all partitions of a * partitioned table will be treated the same way . ) if (use_truncate)/* * Parallel restore is always talking directly to a * server , so no need to see if we should issue BEGIN . public );/* * Issue TRUNCATE with ONLY so that child tables are * not wiped . "TRUNCATE TABLE ONLY %s;\n\n" ,namespace , te->tag));/* * If we have a copy statement , use it . if (te->copyStmt && strlen(te->copyStmt) > 0 )"%s" , te->copyStmt);else /* * Terminate COPY if needed . if (AH->outputKind == OUTPUT_COPYDATA &&public , te->tag);/* close out the transaction started above */ if (use_truncate)public );else if (!defnDumped)/* If we haven't already dumped the defn part, do so now */ "executing %s %s" , te->desc, te->tag);/* * If it has a statistics component that we want , then process that if ((reqs & REQ_STATS) != 0 )/* * If we emitted anything for this TOC entry , that counts as one action * against the transaction - size limit . Commit if it ' s time to . if ((reqs & (REQ_SCHEMA | REQ_DATA | REQ_STATS)) != 0 && ropt->txn_size > 0 )if (++AH->txnCount >= ropt->txn_size)if (AH->connection)public );public );else "COMMIT;\nBEGIN;\n\n" );0 ;if (AH->public .n_errors > 0 && status == WORKER_OK)return status;/* * Allocate a new RestoreOptions block . * This is mainly so we can initialize it , but also for future expansion , void )sizeof (RestoreOptions));/* set any fields that shouldn't default to zeroes */ 0 ;true ;true ;true ;return opts;static void public .ropt;/* This hack is only needed in a data-only restore */ if (ropt->dumpSchema || !ropt->disable_triggers)return ;"disabling triggers for %s" , te->tag);/* * Become superuser if possible , since they are the only ones who can * disable constraint triggers . If - S was not given , assume the initial * user identity is a superuser . ( XXX would it be better to become the * table owner ? ) /* * Disable them . "ALTER TABLE %s DISABLE TRIGGER ALL;\n\n" ,namespace , te->tag));static void public .ropt;/* This hack is only needed in a data-only restore */ if (ropt->dumpSchema || !ropt->disable_triggers)return ;"enabling triggers for %s" , te->tag);/* * Become superuser if possible , since they are the only ones who can * disable constraint triggers . If - S was not given , assume the initial * user identity is a superuser . ( XXX would it be better to become the * table owner ? ) /* * Enable them . "ALTER TABLE %s ENABLE TRIGGER ALL;\n\n" ,namespace , te->tag));/* * Detect whether a TABLE DATA TOC item is performing " load via partition * root " , that is the target table is an ancestor partition rather than the * table the TOC item is nominally for . * * In newer archive files this can be detected by checking for a special * comment placed in te - > defn . In older files we have to fall back to seeing * if the COPY statement targets the named table or some other one . This * will not work for data dumped as INSERT commands , so we could give a false * negative in that case ; fortunately , that ' s a rarely - used option . static bool if (te->defn &&"-- load via partition root " , 27 ) == 0 )return true ;if (te->copyStmt && *te->copyStmt)bool result;/* * Build the initial part of the COPY as it would appear if the * nominal target table is the actual target . If we see anything * else , it must be a load - via - partition - root case . "COPY %s " ,namespace , te->tag));0 ;return result;/* Assume it's not load-via-partition-root */ return false ;/* * This is a routine that is part of the dumper interface , hence the ' Archive * ' parameter . /* Public */ void const void *data, size_t dLen)if (!AH->currToc)"internal error -- WriteData cannot be called outside the context of a DataDumper routine" );/* * 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 . * * The new entry is added to the Archive ' s TOC list . Most callers can ignore * the result value because nothing else need be done , but a few want to * manipulate the TOC entry further . /* Public */ sizeof (TocEntry));if (dumpId > AH->maxDumpId)namespace = opts->namespace ? pg_strdup(opts->namespace ) : NULL;if (opts->nDeps > 0 )sizeof (DumpId));sizeof (DumpId));else 0 ;true : false ;0 ;if (AH->ArchiveEntryPtr != NULL)return newToc;/* Public */ void public .ropt;0 };const char *fmtName;char stamp_str[64 ];/* TOC is always uncompressed */ if (ropt->filename)if (strftime(stamp_str, sizeof (stamp_str), PGDUMP_STRFTIME_FMT,0 )"[unknown]" );";\n; Archive created at %s\n" , stamp_str);"; dbname: %s\n; TOC Entries: %d\n; Compression: %s\n" ,false ),switch (AH->format)case archCustom:"CUSTOM" ;break ;case archDirectory:"DIRECTORY" ;break ;case archTar:"TAR" ;break ;default :"UNKNOWN" ;"; Dump Version: %d.%d-%d\n" ,"; Format: %s\n" , fmtName);"; Integer: %d bytes\n" , (int ) AH->intSize);"; Offset: %d bytes\n" , (int ) AH->offSize);if (AH->archiveRemoteVersion)"; Dumped from database version: %s\n" ,if (AH->archiveDumpVersion)"; Dumped by pg_dump version: %s\n" ,";\n;\n; Selected TOC Entries:\n;\n" );for (te = AH->toc->next; te != AH->toc; te = te->next)/* This bit must match ProcessArchiveRestoreOptions' marking logic */ if (te->section != SECTION_NONE)/* Now, should we print it? */ if (ropt->verbose ||0 )char *sanitized_name;char *sanitized_schema;char *sanitized_owner;/* false );namespace , true );false );"%d; %u %u %s %s %s %s\n" , te->dumpId,if (ropt->verbose && te->nDeps > 0 )int i;";\tdepends on:" );for (i = 0 ; i < te->nDeps; i++)" %d" , te->dependencies[i]);"\n" );/* Enforce strict names checking */ if (ropt->strict_names)if (ropt->filename)/*********** * Large Object Archival /* Called by a dumper to signal start of a LO */ int if (!AH->StartLOPtr)"large-object output not supported in chosen format" );return 1 ;/* Called by a dumper to signal end of a LO */ int if (AH->EndLOPtr)return 1 ;/********** * Large Object Restoration /* * Called by a format handler before a group of LOs is restored void public .ropt;/* * LOs must be restored within a transaction block , since we need the LO * handle to stay open while we write it . Establish a transaction unless * there ' s one being used globally . if (!(ropt->single_txn || ropt->txn_size > 0 ))if (AH->connection)public );else "BEGIN;\n\n" );0 ;/* * Called by a format handler after a group of LOs is restored void public .ropt;if (!(ropt->single_txn || ropt->txn_size > 0 ))if (AH->connection)public );else "COMMIT;\n\n" );"restored %d large object" ,"restored %d large objects" ,/* * Called by a format handler to initiate restoration of a LO void bool drop)bool old_lo_style = (AH->version < K_VERS_1_12);/* Initialize the LO Buffer */ if (AH->lo_buf == NULL)/* First time through (in this process) so allocate the buffer */ 0 ;"restoring large object with OID %u" , oid);/* With an old archive we must do drop and create logic here */ if (old_lo_style && drop)if (AH->connection)if (old_lo_style)if (loOid == 0 || loOid != oid)"could not create large object %u: %s" ,if (AH->loFd == -1 )"could not open large object %u: %s" ,else if (old_lo_style)"SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n" ,else "SELECT pg_catalog.lo_open('%u', %d);\n" ,true ;void if (AH->lo_buf_used > 0 )/* Write remaining bytes from the LO buffer */ false ;if (AH->connection)1 ;else "SELECT pg_catalog.lo_close(0);\n\n" );/*********** * Sorting and Reordering void public .ropt;/* Allocate space for the 'wanted' array, and init it */ bool *) pg_malloc0(sizeof (bool ) * AH->maxDumpId);/* Setup the file */ if (!fh)"could not open TOC file \" %s\": %m" , ropt->tocFile);while (pg_get_line_buf(fh, &linebuf))char *cmnt;char *endptr;/* Truncate line at comment, if any */ ';' );if (cmnt != NULL)0 ] = '\0' ;/* 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 */ 10 );if (endptr == linebuf.data || id <= 0 || id > AH->maxDumpId ||1 ])"line ignored: %s" , linebuf.data);continue ;/* Find TOC entry */ if (!te)"could not find entry for ID %d" ,/* Mark it wanted */ 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 . if (fclose(fh) != 0 )"could not close TOC file: %m" );/********************** * Convenience functions that look like standard IO functions * for writing data when in dump mode . /* Public */ void const char *s, Archive *AH)/* Public */ int const char *fmt,...)int save_errno = errno;char *p;128 ; /* initial assumption about buffer size */ for (;;)/* Allocate work buffer. */ char *) pg_malloc(len);/* Try to format the data. */ if (cnt < len)break ; /* success */ /* Release buffer and loop around to try again with larger len. */ return (int ) cnt;/******************************* * Stuff below here should be ' private ' to the archiver routines static void const char *filename,const pg_compress_specification compression_spec)const char *mode;int fn = -1 ;if (filename)if (strcmp(filename, "-" ) == 0 )else if (AH->FH)else if (AH->fSpec)else if (AH->mode == archModeAppend)else if (!CFH->open_func(filename, fn, mode, CFH))if (filename)"could not open output file \" %s\": %m" , filename);else "could not open output file: %m" );static CompressFileHandle *return (CompressFileHandle *) AH->OF;static void 0 ;if (!EndCompressFileHandle(AH->OF))"could not close output file: %m" );/* * Print formatted text to the output file ( usually stdout ) . int const char *fmt,...)int save_errno = errno;char *p;128 ; /* initial assumption about buffer size */ for (;;)/* Allocate work buffer. */ char *) pg_malloc(len);/* Try to format the data. */ if (cnt < len)break ; /* success */ /* Release buffer and loop around to try again with larger len. */ 1 , cnt, AH);return (int ) cnt;/* * Single place for logic which says ' We are restoring to a direct DB connection ' . static int public .ropt;return (ropt && ropt->useDB && AH->connection);/* * Dump the current contents of the LO data buffer while writing a LO static void if (AH->connection)int res;"wrote %zu byte of large object data (result = %d)" ,"wrote %zu bytes of large object data (result = %d)" ,/* We assume there are no short writes, only errors */ if (res != AH->lo_buf_used)"could not write to large object: %s" ,else const unsigned char *) AH->lo_buf,/* Hack: turn off writingLO so ahwrite doesn't recurse to here */ false ;"SELECT pg_catalog.lowrite(0, %s);\n" , buf->data);true ;0 ;/* * Write buffer to the output file ( usually stdout ) . This is used 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 ) . void const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)int bytes_written = 0 ;if (AH->writingLO)while (AH->lo_buf_used + remaining > AH->lo_buf_size)char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);const char *) ptr + avail;char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);else if (AH->CustomOutPtr)/* * If we ' re doing a restore , and it ' s direct to DB , and we ' re connected * then send it to the DB . else if (RestoringToDB(AH))public , (const char *) ptr, size * nmemb);else if (bytes_written != size * nmemb)/* on some error, we may decide to go on... */ void const char *fmt,...)switch (AH->stage)case STAGE_NONE:/* Do nothing special */ break ;case STAGE_INITIALIZING:if (AH->stage != AH->lastErrorStage)"while INITIALIZING:" );break ;case STAGE_PROCESSING:if (AH->stage != AH->lastErrorStage)"while PROCESSING TOC:" );break ;case STAGE_FINALIZING:if (AH->stage != AH->lastErrorStage)"while FINALIZING:" );break ;if (AH->currentTE != NULL && AH->currentTE != AH->lastErrorTE)"from TOC entry %d; %u %u %s %s %s" ,"(no desc)" ,"(no tag)" ,"(no owner)" );if (AH->public .exit_on_error)1 );else public .n_errors++;#ifdef NOT_USEDstatic void /* Unlink te from list */ /* and insert it after "pos" */ #endif static void /* Unlink te from list */ /* and insert it before "pos" */ /* * Build index arrays for the TOC list * * This should be invoked only after we have created or read in all the TOC * items . * * The arrays are indexed by dump ID ( so entry zero is unused ) . Note that the * array entries run only up to maxDumpId . We might see dependency dump IDs * beyond that ( if the dump was partial ) ; so always check the array bound * before trying to touch an array entry . static void 1 ) * sizeof (TocEntry *));1 ) * sizeof (DumpId));for (te = AH->toc->next; te != AH->toc; te = te->next)/* this check is purely paranoia, maxDumpId should be correct */ if (te->dumpId <= 0 || te->dumpId > maxDumpId)"bad dumpId" );/* tocsByDumpId indexes all TOCs by their dump ID */ /* * tableDataId provides the TABLE DATA item ' s dump ID for each TABLE * TOC entry that has a DATA item . We compute this by reversing the * TABLE DATA item ' s dependency , knowing that a TABLE DATA item has * just one dependency and it is the TABLE item . if (strcmp(te->desc, "TABLE DATA" ) == 0 && te->nDeps > 0 )0 ];/* * The TABLE item might not have been in the archive , if this was * a data - only dump ; but its dump ID should be less than its data * item ' s dump ID , so there should be a place for it in the array . if (tableId <= 0 || tableId > maxDumpId)"bad table dumpId for TABLE DATA item" );/* build index arrays if we didn't already */ if (AH->tocsByDumpId == NULL)if (id > 0 && id <= AH->maxDumpId)return AH->tocsByDumpId[id];return NULL;int if (!te)return 0 ;return te->reqs;int wasSet)int off;/* Save the flag */ /* Write out pgoff_t smallest byte first, prevents endian mismatch */ for (off = 0 ; off < sizeof (pgoff_t); off++)0 xFF);8 ;return sizeof (pgoff_t) + 1 ;int int i;int off;int offsetFlg;/* Initialize to zero */ 0 ;/* Check for old version */ if (AH->version < K_VERS_1_7)/* Prior versions wrote offsets using WriteInt */ /* -1 means not set */ if (i < 0 )return K_OFFSET_POS_NOT_SET;else if (i == 0 )return K_OFFSET_NO_DATA;/* Cast to pgoff_t because it was written as an int. */ return K_OFFSET_POS_SET;/* * Read the flag indicating the state of the data pointer . Check if valid * and die if not . * * This used to be handled by a negative or zero pointer , now we use an * extra byte specifically for the state . 0 xFF;switch (offsetFlg)case K_OFFSET_POS_NOT_SET:case K_OFFSET_NO_DATA:case K_OFFSET_POS_SET:break ;default :"unexpected data offset flag %d" , offsetFlg);/* * Read the bytes for (off = 0 ; off < AH->offSize; off++)if (off < sizeof (pgoff_t))8 );else if (AH->ReadBytePtr(AH) != 0 )"file offset in dump file is too large" );return offsetFlg;int i)int b;/* * This is a bit yucky , but I don ' t want to make the binary format very * dependent 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 )1 );else 0 );for (b = 0 ; b < AH->intSize; b++)0 xFF);8 ;return AH->intSize + 1 ;int int res = 0 ;int bv,int sign = 0 ; /* Default positive */ int bitShift = 0 ;if (AH->version > K_VERS_1_0)/* Read a sign byte */ for (b = 0 ; b < AH->intSize; b++)0 xFF;if (bv != 0 )8 ;if (sign)return res;const char *c)if (c)int len = strlen(c);else 1 );return res;char *char *buf;int l;if (l < 0 )else char *) pg_malloc(l + 1 );'\0' ;return buf;static bool const char *dir, const char *filename)struct stat st;char buf[MAXPGPATH];if (snprintf(buf, MAXPGPATH, "%s/%s" , dir, filename) >= MAXPGPATH)"directory name too long: \" %s\"" , dir);return (stat(buf, &st) == 0 && S_ISREG(st.st_mode));static int char sig[6 ]; /* More than enough */ int wantClose = 0 ;"attempting to ascertain archive format" );0 ;512 ;512 );0 ;0 ;if (AH->fSpec)struct stat st;1 ;/* * Check if the specified archive is a directory . If so , check if * there ' s a " toc . dat " ( or " toc . dat . { gz , lz4 , zst } " ) file in it . if (stat(AH->fSpec, &st) == 0 && S_ISDIR(st.st_mode))if (_fileExistsInDirectory(AH->fSpec, "toc.dat" ))return AH->format;#ifdef HAVE_LIBZif (_fileExistsInDirectory(AH->fSpec, "toc.dat.gz" ))return AH->format;#endif #ifdef USE_LZ4if (_fileExistsInDirectory(AH->fSpec, "toc.dat.lz4" ))return AH->format;#endif #ifdef USE_ZSTDif (_fileExistsInDirectory(AH->fSpec, "toc.dat.zst" ))return AH->format;#endif "directory \" %s\" does not appear to be a valid archive (\" toc.dat\" does not exist)" ,/* keep compiler quiet */ else if (!fh)"could not open input file \" %s\": %m" , AH->fSpec);else if (!fh)"could not open input file: %m" );if ((cnt = fread(sig, 1 , 5 , fh)) != 5 )if (ferror(fh))"could not read input file: %m" );else "input file is too short (read %lu, expected 5)" ,unsigned long ) cnt);/* Save it, just in case we need it later */ 0 ], sig, 5 );5 ;if (strncmp(sig, "PGDMP" , 5 ) == 0 )/* It's custom format, stop here */ 1 ;else /* * * Maybe * we have a tar archive format file or a text dump . . . So , * read first 512 byte header . . . 1 , 512 - AH->lookaheadLen, fh);/* read failure is checked below */ if (AH->lookaheadLen >= strlen(TEXT_DUMPALL_HEADER) &&0 ||0 ))/* * looks like it ' s probably a text format dump . so suggest they * try psql "input file appears to be a text format dump. Please use psql." );if (AH->lookaheadLen != 512 )if (feof(fh))"input file does not appear to be a valid archive (too short?)" );else if (!isValidTarHeader(AH->lookahead))"input file does not appear to be a valid tar archive" );/* Close the file if we opened it */ if (wantClose)if (fclose(fh) != 0 )"could not close input file: %m" );/* Forget lookahead, since we'll re-read header after re-opening */ 0 ;0 ;return AH->format;/* * Allocate an archive handle static ArchiveHandle *const char *FileSpec, const ArchiveFormat fmt,const pg_compress_specification compression_spec,bool dosync, ArchiveMode mode,0 };"allocating AH for %s, format %d" ,"(stdio)" , fmt);sizeof (ArchiveHandle));/* initialize for backwards compatible string processing */ public .encoding = 0 ; /* PG_SQL_ASCII */ public .std_strings = false ;/* sql error handling */ public .exit_on_error = true ;public .n_errors = 0 ;sizeof (int );sizeof (pgoff_t);if (FileSpec)/* * Not used ; maybe later . . . . * * AH - > workDir = pg_strdup ( FileSpec ) ; for ( i = strlen ( FileSpec ) ; i > 0 ; * i - - ) if ( AH - > workDir [ i - 1 ] = = ' / ' ) else /* unknown */ /* ditto */ /* ditto */ /* ditto */ sizeof (TocEntry));0 , sizeof (AH->sqlparse));/* Open stdout with no compression for AH output handle */ if (!CFH->open_func(NULL, fileno(stdout), PG_BINARY_A, CFH))"could not open stdout for appending: %m" );/* * On Windows , we need to use binary mode to read / write non - text files , * which include all archive formats as well as compressed plain text . * Force stdin / stdout into binary mode if that is what we are using . #ifdef WIN32if ((fmt != archNull || compression_spec.algorithm != PG_COMPRESSION_NONE) &&"" ) == 0 ))if (mode == archModeWrite)else #endif if (fmt == archUnknown)else switch (AH->format)case archCustom:break ;case archNull:break ;case archDirectory:break ;case archTar:break ;default :"unrecognized file format \" %d\"" , AH->format);return AH;/* * Write out all data ( tables & LOs ) void if (pstate && pstate->numWorkers > 1 )/* * In parallel mode , this code runs in the leader process . We * construct an array of candidate TEs , then sort it into decreasing * size order , then dispatch each TE to a data - transfer worker . By * dumping larger tables first , we avoid getting into a situation * where we ' re down to one job and it ' s big , losing parallelism . int ntes;sizeof (TocEntry *));0 ;for (te = AH->toc->next; te != AH->toc; te = te->next)/* Consider only TEs with dataDumper functions ... */ if (!te->dataDumper)continue ;/* ... and ignore ones not enabled for dump */ if ((te->reqs & REQ_DATA) == 0 )continue ;if (ntes > 1 )sizeof (TocEntry *), TocEntrySizeCompareQsort);for (int i = 0 ; i < ntes; i++)/* Now wait for workers to finish. */ else /* Non-parallel mode: just dump all candidate TEs sequentially. */ for (te = AH->toc->next; te != AH->toc; te = te->next)/* Must have same filter conditions as above */ if (!te->dataDumper)continue ;if ((te->reqs & REQ_DATA) == 0 )continue ;/* * Callback function that ' s invoked in the leader process after a step has * been parallel dumped . * * We don ' t need to do anything except check for worker failure . static void int status,void *callback_data)"finished item %d %s %s" ,if (status != 0 )"worker process failed: exit code %d" ,void if (strcmp(te->desc, "BLOBS" ) == 0 )else if (startPtr != NULL)/* * The user - provided DataDumper routine needs to call AH - > WriteData if (endPtr != NULL)void char workbuf[32 ];int tocCount;int i;/* count entries that will actually be dumped */ 0 ;for (te = AH->toc->next; te != AH->toc; te = te->next)if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_STATS | REQ_SPECIAL)) != 0 )/* printf("%d TOC Entries to save\n", tocCount); */ for (te = AH->toc->next; te != AH->toc; te = te->next)if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_STATS | REQ_SPECIAL)) == 0 )continue ;1 : 0 );/* OID is recorded as a string for historical reasons */ "%u" , te->catalogId.tableoid);"%u" , te->catalogId.oid);if (te->defnLen)/* * defnLen should only be set for custom format ' s second call to * WriteToc ( ) , which rewrites the TOC in place to update data * offsets . Instead of calling the defnDumper a second time * ( which could involve re - executing queries ) , just skip writing * the entry . While regenerating the definition should * theoretically produce the same result as before , it ' s expensive * and feels risky . * * The custom format only calls WriteToc ( ) a second time if * fseeko ( ) is usable ( see _ CloseArchive ( ) in pg_backup_custom . c ) , * so we can safely use it without checking . For other formats , * we fail because one of our assumptions must no longer hold * true . * * XXX This is a layering violation , but the alternative is an * awkward and complicated callback infrastructure for this * special case . This might be worth revisiting in the future . if (AH->format != archCustom)"unexpected TOC entry in WriteToc(): %d %s %s" ,if (fseeko(AH->FH, te->defnLen, SEEK_CUR) != 0 )"error during file seek: %m" );else if (te->defnDumper)char *defn = te->defnDumper((Archive *) AH, te->defnDumperArg, te);else namespace );"false" );/* Dump list of dependencies */ for (i = 0 ; i < te->nDeps; i++)"%d" , te->dependencies[i]);/* Terminate List */ if (AH->WriteExtraTocPtr)void int i;char *tmp;int depIdx;int depSize;bool is_supported;0 ;for (i = 0 ; i < AH->tocCount; i++)sizeof (TocEntry));if (te->dumpId > AH->maxDumpId)/* Sanity check */ if (te->dumpId <= 0 )"entry ID %d out of range -- perhaps a corrupt TOC" ,if (AH->version >= K_VERS_1_8)"%u" , &te->catalogId.tableoid);else "%u" , &te->catalogId.oid);if (AH->version >= K_VERS_1_11)else /* * Rules for pre - 8 . 4 archives wherein pg_dump hasn ' t classified * the entries into sections . This list need not cover entry * types added later than 8 . 4 . if (strcmp(te->desc, "COMMENT" ) == 0 ||"ACL" ) == 0 ||"ACL LANGUAGE" ) == 0 )else if (strcmp(te->desc, "TABLE DATA" ) == 0 ||"BLOBS" ) == 0 ||"BLOB COMMENTS" ) == 0 )else if (strcmp(te->desc, "CONSTRAINT" ) == 0 ||"CHECK CONSTRAINT" ) == 0 ||"FK CONSTRAINT" ) == 0 ||"INDEX" ) == 0 ||"RULE" ) == 0 ||"TRIGGER" ) == 0 )else if (AH->version >= K_VERS_1_3)if (AH->version >= K_VERS_1_6)namespace = ReadStr(AH);if (AH->version >= K_VERS_1_10)if (AH->version >= K_VERS_1_14)if (AH->version >= K_VERS_1_16)true ;if (AH->version < K_VERS_1_9)false ;else if (strcmp(tmp, "true" ) == 0 )false ;if (!is_supported)"restoring tables WITH OIDS is not supported anymore" );/* Read TOC entry dependencies */ if (AH->version >= K_VERS_1_5)100 ;sizeof (DumpId) * depSize);0 ;for (;;)if (!tmp)break ; /* end of list */ if (depIdx >= depSize)2 ;sizeof (DumpId) * depSize);"%d" , &deps[depIdx]);if (depIdx > 0 ) /* We have a non-null entry */ sizeof (DumpId) * depIdx);else 0 ;else 0 ;0 ;if (AH->ReadExtraTocPtr)"read TOC entry %d (ID %d) for %s %s" ,/* link completed entry into TOC circular list */ /* special processing immediately upon read for some items */ if (strcmp(te->desc, "ENCODING" ) == 0 )else if (strcmp(te->desc, "STDSTRINGS" ) == 0 )else if (strcmp(te->desc, "SEARCHPATH" ) == 0 )static void /* te->defn should have the form SET client_encoding = 'foo'; */ char *defn = pg_strdup(te->defn);char *ptr1;char *ptr2 = NULL;int encoding;'\' '); if (ptr1)'\' '); if (ptr2)'\0' ;if (encoding < 0 )"unrecognized encoding \" %s\"" ,public .encoding = encoding;else "invalid ENCODING item: %s" ,static void /* te->defn should have the form SET standard_conforming_strings = 'x'; */ char *ptr1;'\' '); if (ptr1 && strncmp(ptr1, "'on'" , 4 ) == 0 )public .std_strings = true ;else if (ptr1 && strncmp(ptr1, "'off'" , 5 ) == 0 )public .std_strings = false ;else "invalid STDSTRINGS item: %s" ,static void /* * te - > defn should contain a command to set search_path . We just copy it * verbatim for use later . public .searchpath = pg_strdup(te->defn);static void const char *missing_name;if (ropt->schemaNames.head != NULL)if (missing_name != NULL)"schema \" %s\" not found" , missing_name);if (ropt->tableNames.head != NULL)if (missing_name != NULL)"table \" %s\" not found" , missing_name);if (ropt->indexNames.head != NULL)if (missing_name != NULL)"index \" %s\" not found" , missing_name);if (ropt->functionNames.head != NULL)if (missing_name != NULL)"function \" %s\" not found" , missing_name);if (ropt->triggerNames.head != NULL)if (missing_name != NULL)"trigger \" %s\" not found" , missing_name);/* * Determine whether we want to restore this TOC entry . * * Returns 0 if entry should be skipped , or some combination of the * REQ_SCHEMA , REQ_DATA , and REQ_STATS bits if we want to restore schema , data * and / or statistics portions of this TOC entry , or REQ_SPECIAL if it ' s a * special entry . static int int res = REQ_SCHEMA | REQ_DATA;public .ropt;/* These items are treated specially */ if (strcmp(te->desc, "ENCODING" ) == 0 ||"STDSTRINGS" ) == 0 ||"SEARCHPATH" ) == 0 )return REQ_SPECIAL;if (strcmp(te->desc, "STATISTICS DATA" ) == 0 )if (!ropt->dumpStatistics)return 0 ;/* * DATABASE and DATABASE PROPERTIES also have a special rule : they are * restored in createDB mode , and not restored otherwise , independently of * all else . if (strcmp(te->desc, "DATABASE" ) == 0 ||"DATABASE PROPERTIES" ) == 0 )if (ropt->createDB)return REQ_SCHEMA;else return 0 ;/* * Process exclusions that affect certain classes of TOC entries . /* If it's an ACL, maybe ignore it */ if (ropt->aclsSkip && _tocEntryIsACL(te))return 0 ;/* If it's a comment, maybe ignore it */ if (ropt->no_comments && strcmp(te->desc, "COMMENT" ) == 0 )return 0 ;/* If it's a policy, maybe ignore it */ if (ropt->no_policies &&"POLICY" ) == 0 ||"ROW SECURITY" ) == 0 ))return 0 ;/* * If it ' s a comment on a policy , a publication , or a subscription , maybe * ignore it . if (strcmp(te->desc, "COMMENT" ) == 0 )if (ropt->no_policies &&"POLICY" , strlen("POLICY" )) == 0 )return 0 ;if (ropt->no_publications &&"PUBLICATION" , strlen("PUBLICATION" )) == 0 )return 0 ;if (ropt->no_subscriptions &&"SUBSCRIPTION" , strlen("SUBSCRIPTION" )) == 0 )return 0 ;/* * If it ' s a publication or a table part of a publication , maybe ignore * it . if (ropt->no_publications &&"PUBLICATION" ) == 0 ||"PUBLICATION TABLE" ) == 0 ||"PUBLICATION TABLES IN SCHEMA" ) == 0 ))return 0 ;/* If it's a security label, maybe ignore it */ if (ropt->no_security_labels && strcmp(te->desc, "SECURITY LABEL" ) == 0 )return 0 ;/* * If it ' s a security label on a publication or a subscription , maybe * ignore it . if (strcmp(te->desc, "SECURITY LABEL" ) == 0 )if (ropt->no_publications &&"PUBLICATION" , strlen("PUBLICATION" )) == 0 )return 0 ;if (ropt->no_subscriptions &&"SUBSCRIPTION" , strlen("SUBSCRIPTION" )) == 0 )return 0 ;/* If it's a subscription, maybe ignore it */ if (ropt->no_subscriptions && strcmp(te->desc, "SUBSCRIPTION" ) == 0 )return 0 ;/* Ignore it if section is not to be dumped/restored */ switch (curSection)case SECTION_PRE_DATA:if (!(ropt->dumpSections & DUMP_PRE_DATA))return 0 ;break ;case SECTION_DATA:if (!(ropt->dumpSections & DUMP_DATA))return 0 ;break ;case SECTION_POST_DATA:if (!(ropt->dumpSections & DUMP_POST_DATA))return 0 ;break ;default :/* shouldn't get here, really, but ignore it */ return 0 ;/* Ignore it if rejected by idWanted[] (cf. SortTocFromFile) */ if (ropt->idWanted && !ropt->idWanted[te->dumpId - 1 ])return 0 ;/* * Check options for selective dump / restore . if (strcmp(te->desc, "ACL" ) == 0 ||"COMMENT" ) == 0 ||"STATISTICS DATA" ) == 0 ||"SECURITY LABEL" ) == 0 )/* Database properties react to createDB, not selectivity options. */ if (strncmp(te->tag, "DATABASE " , 9 ) == 0 )if (!ropt->createDB)return 0 ;else if (ropt->schemaNames.head != NULL ||/* * In a selective dump / restore , we want to restore these dependent * TOC entry types only if their parent object is being restored . * Without selectivity options , we let through everything in the * archive . Note there may be such entries with no parent , eg * non - default ACLs for built - in objects . Also , we make * per - column ACLs additionally depend on the table ' s ACL if any * to ensure correct restore order , so those dependencies should * be ignored in this check . * * This code depends on the parent having been marked already , * which should be the case ; if it isn ' t , perhaps due to * SortTocFromFile rearrangement , skipping the dependent entry * seems prudent anyway . * * Ideally we ' d handle , eg , table CHECK constraints this way too . * But it ' s hard to tell which of their dependencies is the one to * consult . bool dumpthis = false ;for (int i = 0 ; i < te->nDeps; i++)if (!pte)continue ; /* probably shouldn't happen */ if (strcmp(pte->desc, "ACL" ) == 0 )continue ; /* ignore dependency on another ACL */ if (pte->reqs == 0 )continue ; /* this object isn't marked, so ignore it */ /* Found a parent to be dumped, so we want to dump this too */ true ;break ;if (!dumpthis)return 0 ;else /* Apply selective-restore rules for standalone TOC entries. */ if (ropt->schemaNames.head != NULL)/* If no namespace is specified, it means all. */ if (!te->namespace )return 0 ;if (!simple_string_list_member(&ropt->schemaNames, te->namespace ))return 0 ;if (ropt->schemaExcludeNames.head != NULL &&namespace &&namespace ))return 0 ;if (ropt->selTypes)if (strcmp(te->desc, "TABLE" ) == 0 ||"TABLE DATA" ) == 0 ||"VIEW" ) == 0 ||"FOREIGN TABLE" ) == 0 ||"MATERIALIZED VIEW" ) == 0 ||"MATERIALIZED VIEW DATA" ) == 0 ||"SEQUENCE" ) == 0 ||"SEQUENCE SET" ) == 0 )if (!ropt->selTable)return 0 ;if (ropt->tableNames.head != NULL &&return 0 ;else if (strcmp(te->desc, "INDEX" ) == 0 )if (!ropt->selIndex)return 0 ;if (ropt->indexNames.head != NULL &&return 0 ;else if (strcmp(te->desc, "FUNCTION" ) == 0 ||"AGGREGATE" ) == 0 ||"PROCEDURE" ) == 0 )if (!ropt->selFunction)return 0 ;if (ropt->functionNames.head != NULL &&return 0 ;else if (strcmp(te->desc, "TRIGGER" ) == 0 )if (!ropt->selTrigger)return 0 ;if (ropt->triggerNames.head != NULL &&return 0 ;else return 0 ;/* * Determine whether the TOC entry contains schema and / or data components , * and mask off inapplicable REQ bits . If it had a dataDumper , assume * it ' s both schema and data . Otherwise it ' s probably schema - only , but * there are exceptions . if (!te->hadDumper)/* * Special Case : If ' SEQUENCE SET ' or anything to do with LOs , then it * is considered a data entry . We don ' t need to check for BLOBS or * old - style BLOB COMMENTS entries , because they will have hadDumper = * true . . . but we do need to check new - style BLOB ACLs , comments , * etc . if (strcmp(te->desc, "SEQUENCE SET" ) == 0 ||"BLOB" ) == 0 ||"BLOB METADATA" ) == 0 ||"ACL" ) == 0 &&"LARGE OBJECT" , 12 ) == 0 ) ||"COMMENT" ) == 0 &&"LARGE OBJECT" , 12 ) == 0 ) ||"SECURITY LABEL" ) == 0 &&"LARGE OBJECT" , 12 ) == 0 ))else /* * If there ' s no definition command , there ' s no schema component . Treat * " load via partition root " comments as not schema . if (!te->defn || !te->defn[0 ] ||"-- load via partition root " , 27 ) == 0 )/* * Special case : < Init > type with < Max OID > tag ; this is obsolete and we * always ignore it . if ((strcmp(te->desc, "<Init>" ) == 0 ) && (strcmp(te->tag, "Max OID" ) == 0 ))return 0 ;/* Mask it if we don't want data */ if (!ropt->dumpData)/* * The sequence_data option overrides dumpData for SEQUENCE SET . * * In binary - upgrade mode , even with dumpData unset , we do not mask * out large objects . ( Only large object definitions , comments and * other metadata should be generated in binary - upgrade mode , not the * actual data , but that need not concern us here . ) if (!(ropt->sequence_data && strcmp(te->desc, "SEQUENCE SET" ) == 0 ) &&"BLOB" ) == 0 ||"BLOB METADATA" ) == 0 ||"ACL" ) == 0 &&"LARGE OBJECT" , 12 ) == 0 ) ||"COMMENT" ) == 0 &&"LARGE OBJECT" , 12 ) == 0 ) ||"SECURITY LABEL" ) == 0 &&"LARGE OBJECT" , 12 ) == 0 ))))/* Mask it if we don't want schema */ if (!ropt->dumpSchema)return res;/* * Identify which pass we should restore this TOC entry in . * * See notes with the RestorePass typedef in pg_backup_archiver . h . static RestorePass/* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */ if (strcmp(te->desc, "ACL" ) == 0 ||"ACL LANGUAGE" ) == 0 ||"DEFAULT ACL" ) == 0 )return RESTORE_PASS_ACL;if (strcmp(te->desc, "EVENT TRIGGER" ) == 0 ||"MATERIALIZED VIEW DATA" ) == 0 )return RESTORE_PASS_POST_ACL;/* * Comments and security labels need to be emitted in the same pass as * their parent objects . ACLs haven ' t got comments and security labels , * and neither do matview data objects , but event triggers do . * ( Fortunately , event triggers haven ' t got ACLs , or we ' d need yet another * weird special case . ) if ((strcmp(te->desc, "COMMENT" ) == 0 ||"SECURITY LABEL" ) == 0 ) &&"EVENT TRIGGER " , 14 ) == 0 )return RESTORE_PASS_POST_ACL;/* * If statistics data is dependent on materialized view data , it must be * deferred to RESTORE_PASS_POST_ACL . Those entries are already marked as * SECTION_POST_DATA , and some other stats entries ( e . g . , index stats ) * will also be marked as SECTION_POST_DATA . Additionally , our lookahead * code in fetchAttributeStats ( ) assumes that we dump all statistics data * entries in TOC order . To ensure this assumption holds , we move all * statistics data entries in SECTION_POST_DATA to RESTORE_PASS_POST_ACL . if (strcmp(te->desc, "STATISTICS DATA" ) == 0 &&return RESTORE_PASS_POST_ACL;/* All else can be handled in the main pass. */ return RESTORE_PASS_MAIN;/* * Identify TOC entries that are ACLs . * * Note : it seems worth duplicating some code here to avoid a hard - wired * assumption that these are exactly the same entries that we restore during * the RESTORE_PASS_ACL phase . static bool /* "ACL LANGUAGE" was a crock emitted only in PG 7.4 */ if (strcmp(te->desc, "ACL" ) == 0 ||"ACL LANGUAGE" ) == 0 ||"DEFAULT ACL" ) == 0 )return true ;return false ;/* * Issue SET commands for parameters that we want to have set the same way * at all times during execution of a restore script . static void public .ropt;/* * Disable timeouts to allow for slow commands , idle parallel workers , etc "SET statement_timeout = 0;\n" );"SET lock_timeout = 0;\n" );"SET idle_in_transaction_session_timeout = 0;\n" );"SET transaction_timeout = 0;\n" );/* Select the correct character set encoding */ "SET client_encoding = '%s';\n" ,public .encoding));/* Select the correct string literal syntax */ "SET standard_conforming_strings = %s;\n" ,public .std_strings ? "on" : "off" );/* Select the role to be used during restore */ if (ropt && ropt->use_role)"SET ROLE %s;\n" , fmtId(ropt->use_role));/* Select the dump-time search_path */ if (AH->public .searchpath)"%s" , AH->public .searchpath);/* Make sure function checking is disabled */ "SET check_function_bodies = false;\n" );/* Ensure that all valid XML data will be accepted */ "SET xmloption = content;\n" );/* Avoid annoying notices etc */ "SET client_min_messages = warning;\n" );if (!AH->public .std_strings)"SET escape_string_warning = off;\n" );/* Adjust row-security state */ if (ropt && ropt->enable_row_security)"SET row_security = on;\n" );else "SET row_security = off;\n" );/* * In - - transaction - size mode , we should always be in a transaction when * we begin to restore objects . if (ropt && ropt->txn_size > 0 )if (AH->connection)public );else "\nBEGIN;\n" );0 ;"\n" );/* * Issue a SET SESSION AUTHORIZATION command . Caller is responsible * for updating state if appropriate . If user is NULL or an empty string , * the specification DEFAULT will be used . static void const char *user)"SET SESSION AUTHORIZATION " );/* * SQL requires a string literal here . Might as well be correct . if (user && *user)else "DEFAULT" );';' );if (RestoringToDB(AH))if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)/* NOT warn_or_exit_horribly... use -O instead to skip this. */ "could not set session user to \" %s\": %s" ,else "%s\n\n" , cmd->data);/* * Issue the commands to connect to the specified database . * * If we ' re currently restoring right into a database , this will * actually establish a connection . Otherwise it puts a \ connect into * the script output . static void const char *dbname)if (RestoringToDB(AH))else public .ropt;/* * We must temporarily exit restricted mode for \ connect , etc . * Anything added between this line and the following \ restrict must * be careful to avoid any possible meta - command injection vectors . "\\unrestrict %s\n" , ropt->restrict_key);"%s" , connectbuf.data);"\\restrict %s\n\n" , ropt->restrict_key);/* * NOTE : currUser keeps track of what the imaginary session user in our * script is . It ' s now effectively reset to the original userID . /* don't assume we still know the output schema, tablespace, etc either */ /* re-establish fixed state */ /* * Become the specified user , and update state to avoid redundant commands * * NULL or empty argument is taken to mean restoring the session default static void const char *user)if (!user)"" ; /* avoid null pointers */ if (AH->currUser && strcmp(AH->currUser, user) == 0 )return ; /* no need to do anything */ /* * NOTE : currUser keeps track of what the imaginary session user in our * script is /* * Become the owner of the given TOC entry object . If * changes in ownership are not allowed , this doesn ' t do anything . static void public .ropt;if (ropt && (ropt->noOwner || !ropt->use_setsessauth))return ;/* * Issue the commands to select the specified schema as the current schema * in the target database . static void const char *schemaName)/* * If there was a SEARCHPATH TOC entry , we ' re supposed to just stay with * that search_path rather than switching to entry - specific paths . * Otherwise , it ' s an old archive that will not restore correctly unless * we set the search_path as it ' s expecting . if (AH->public .searchpath)return ;if (!schemaName || *schemaName == '\0' ||0 ))return ; /* no need to do anything */ "SET search_path = %s" ,if (strcmp(schemaName, "pg_catalog" ) != 0 )", pg_catalog" );if (RestoringToDB(AH))if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)"could not set \" search_path\" to \" %s\": %s" ,else "%s;\n\n" , qry->data);/* * Issue the commands to select the specified tablespace as the current one * in the target database . static void const char *tablespace)public .ropt;const char *want,/* do nothing in --no-tablespaces mode */ if (ropt->noTablespace)return ;/* no need to do anything for non-tablespace object */ if (!want)return ;if (have && strcmp(want, have) == 0 )return ; /* no need to do anything */ if (strcmp(want, "" ) == 0 )/* We want the tablespace to be the database's default */ "SET default_tablespace = ''" );else /* We want an explicit tablespace */ "SET default_tablespace = %s" , fmtId(want));if (RestoringToDB(AH))if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)"could not set \" default_tablespace\" to %s: %s" ,else "%s;\n\n" , qry->data);/* * Set the proper default_table_access_method value for the table . static void const char *tableam)public .ropt;const char *want,/* do nothing in --no-table-access-method mode */ if (ropt->noTableAm)return ;if (!want)return ;if (have && strcmp(want, have) == 0 )return ;"SET default_table_access_method = %s;" , fmtId(want));if (RestoringToDB(AH))if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)"could not set \" default_table_access_method\": %s" ,else "%s\n\n" , cmd->data);/* * Set the proper default table access method for a table without storage . * Currently , this is required only for partitioned tables with a table AM . static void public .ropt;const char *tableam = te->tableam;/* do nothing in --no-table-access-method mode */ if (ropt->noTableAm)return ;if (!tableam)return ;"ALTER TABLE " );"%s " , fmtQualifiedId(te->namespace , te->tag));"SET ACCESS METHOD %s;" ,if (RestoringToDB(AH))if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)"could not alter table access method: %s" ,else "%s\n\n" , cmd->data);/* * Extract an object description for a TOC entry , and append it to buf . * * This is used for ALTER . . . OWNER TO . * * If the object type has no owner , do nothing . static void const TocEntry *te)const char *type = te->desc;/* objects that don't require special decoration */ if (strcmp(type, "COLLATION" ) == 0 ||"CONVERSION" ) == 0 ||"DOMAIN" ) == 0 ||"FOREIGN TABLE" ) == 0 ||"MATERIALIZED VIEW" ) == 0 ||"SEQUENCE" ) == 0 ||"STATISTICS" ) == 0 ||"TABLE" ) == 0 ||"TEXT SEARCH DICTIONARY" ) == 0 ||"TEXT SEARCH CONFIGURATION" ) == 0 ||"TYPE" ) == 0 ||"VIEW" ) == 0 ||/* non-schema-specified objects */ "DATABASE" ) == 0 ||"PROCEDURAL LANGUAGE" ) == 0 ||"SCHEMA" ) == 0 ||"EVENT TRIGGER" ) == 0 ||"FOREIGN DATA WRAPPER" ) == 0 ||"SERVER" ) == 0 ||"PUBLICATION" ) == 0 ||"SUBSCRIPTION" ) == 0 )"%s " , type);if (te->namespace && *te->namespace )"%s." , fmtId(te->namespace ));/* LOs just have a name, but it's numeric so must not use fmtId */ else if (strcmp(type, "BLOB" ) == 0 )"LARGE OBJECT %s" , te->tag);/* * These object types require additional decoration . Fortunately , the * information needed is exactly what ' s in the DROP command . else if (strcmp(type, "AGGREGATE" ) == 0 ||"FUNCTION" ) == 0 ||"OPERATOR" ) == 0 ||"OPERATOR CLASS" ) == 0 ||"OPERATOR FAMILY" ) == 0 ||"PROCEDURE" ) == 0 )/* Chop "DROP " off the front and make a modifiable copy */ char *first = pg_strdup(te->dropStmt + 5 );char *last;/* point to last character in string */ 1 ;/* Strip off any ';' or '\n' at the end */ while (last >= first && (*last == '\n' || *last == ';' ))1 ) = '\0' ;return ;/* these object types don't have separate owners */ else if (strcmp(type, "CAST" ) == 0 ||"CHECK CONSTRAINT" ) == 0 ||"CONSTRAINT" ) == 0 ||"DATABASE PROPERTIES" ) == 0 ||"DEFAULT" ) == 0 ||"FK CONSTRAINT" ) == 0 ||"INDEX" ) == 0 ||"RULE" ) == 0 ||"TRIGGER" ) == 0 ||"ROW SECURITY" ) == 0 ||"POLICY" ) == 0 ||"USER MAPPING" ) == 0 )/* do nothing */ else "don't know how to set owner for object type \" %s\"" , type);/* * Emit the SQL commands to create the object represented by a TOC entry * * This now also includes issuing an ALTER OWNER command to restore the * object ' s ownership , if wanted . But note that the object ' s permissions * will remain at default , until the matching ACL TOC entry is restored . static void const char *pfx)public .ropt;/* * Select owner , schema , tablespace and default AM as necessary . The * default access method for partitioned tables is handled after * generating the object definition , as it requires an ALTER command * rather than SET . namespace );if (te->relkind != RELKIND_PARTITIONED_TABLE)/* Emit header comment for item */ if (!AH->noTocComments)char *sanitized_name;char *sanitized_schema;char *sanitized_owner;"--\n" );if (AH->public .verbose)"-- TOC entry %d (class %u OID %u)\n" ,if (te->nDeps > 0 )int i;"-- Dependencies:" );for (i = 0 ; i < te->nDeps; i++)" %d" , te->dependencies[i]);"\n" );false );namespace , true );true );"-- %sName: %s; Type: %s; Schema: %s; Owner: %s" ,if (te->tablespace && strlen(te->tablespace) > 0 && !ropt->noTablespace)char *sanitized_tablespace;false );"; Tablespace: %s" , sanitized_tablespace);"\n" );if (AH->PrintExtraTocPtr != NULL)"--\n\n" );/* * Actually print the definition . Normally we can just print the defn * string if any , but we have four special cases : * * 1 . A crude hack for suppressing AUTHORIZATION clause that old pg_dump * versions put into CREATE SCHEMA . Don ' t mutate the variant for schema * " public " that is a comment . We have to do this when - - no - owner mode is * selected . This is ugly , but I see no other good way . . . * * 2 . BLOB METADATA entries need special processing since their defn * strings are just lists of OIDs , not complete SQL commands . * * 3 . ACL LARGE OBJECTS entries need special processing because they * contain only one copy of the ACL GRANT / REVOKE commands , which we must * apply to each large object listed in the associated BLOB METADATA . * * 4 . Entries with a defnDumper need to call it to generate the * definition . This is primarily intended to provide a way to save memory * for objects that would otherwise need a lot of it ( e . g . , statistics * data ) . if (ropt->noOwner &&"SCHEMA" ) == 0 && strncmp(te->defn, "--" , 2 ) != 0 )"CREATE SCHEMA %s;\n\n\n" , fmtId(te->tag));else if (strcmp(te->desc, "BLOB METADATA" ) == 0 )"SELECT pg_catalog.lo_create('" , "')" );else if (strcmp(te->desc, "ACL" ) == 0 &&"LARGE OBJECTS" , 13 ) == 0 )else if (te->defnLen && AH->format != archTar)/* * If defnLen is set , the defnDumper has already been called for this * TOC entry . We don ' t normally expect a defnDumper to be called for * a TOC entry a second time in _ printTocEntry ( ) , but there ' s an * exception . The tar format first calls WriteToc ( ) , which scans the * entire TOC , and then it later calls RestoreArchive ( ) to generate * restore . sql , which scans the TOC again . There doesn ' t appear to be * a good way to prevent a second defnDumper call in this case without * storing the definition in memory , which defeats the purpose . This * second defnDumper invocation should generate the same output as the * first , but even if it doesn ' t , the worst - case scenario is that * restore . sql might have different statistics data than the archive . * * In all other cases , encountering a TOC entry a second time in * _ printTocEntry ( ) is unexpected , so we fail because one of our * assumptions must no longer hold true . * * XXX This is a layering violation , but the alternative is an awkward * and complicated callback infrastructure for this special case . This * might be worth revisiting in the future . "unexpected TOC entry in _printTocEntry(): %d %s %s" ,else if (te->defnDumper)char *defn = te->defnDumper((Archive *) AH, te->defnDumperArg, te);"%s\n\n" , defn);else if (te->defn && strlen(te->defn) > 0 )"%s\n\n" , te->defn);/* * If the defn string contains multiple SQL commands , txn_size mode * should count it as N actions not one . But rather than build a full * SQL parser , approximate this by counting semicolons . One case * where that tends to be badly fooled is function definitions , so * ignore them . ( restore_toc_entry will count one action anyway . ) if (ropt->txn_size > 0 &&"FUNCTION" ) != 0 &&"PROCEDURE" ) != 0 )const char *p = te->defn;int nsemis = 0 ;while ((p = strchr(p, ';' )) != NULL)if (nsemis > 1 )1 ;/* * If we aren ' t using SET SESSION AUTH to determine ownership , we must * instead issue an ALTER OWNER command . Schema " public " is special ; when * a dump emits a comment in lieu of creating it , we use ALTER OWNER even * when using SET SESSION for all other objects . We assume that anything * without a DROP command is not a separately ownable object . if (!ropt->noOwner &&"SCHEMA" ) == 0 &&"--" , 2 ) == 0 )) &&0 &&0 )if (strcmp(te->desc, "BLOB METADATA" ) == 0 )/* BLOB METADATA needs special code to handle multiple LOs */ char *cmdEnd = psprintf(" OWNER TO %s" , fmtId(te->owner));"ALTER LARGE OBJECT " , cmdEnd);else /* For all other cases, we can use _getObjectDescription */ /* * If _ getObjectDescription ( ) didn ' t fill the buffer , then there * is no owner . if (temp.data[0 ])"ALTER %s OWNER TO %s;\n\n" ,/* * Select a partitioned table ' s default AM , once the table definition has * been generated . if (te->relkind == RELKIND_PARTITIONED_TABLE)/* * If it ' s an ACL entry , it might contain SET SESSION AUTHORIZATION * commands , so we can no longer assume we know the current auth setting . if (_tocEntryIsACL(te))/* * Write the file header for a custom - format archive void struct tm crtm;"PGDMP" , 5 ); /* Magic code */ public .remoteVersionStr);void char *errmsg;char vmaj,int fmt;/* * If we haven ' t already read the header , do so . * * NB : this code must agree with _ discoverArchiveFormat ( ) . Maybe find a * way to unify the cases ? if (!AH->readHeader)char tmpMag[7 ];5 );if (strncmp(tmpMag, "PGDMP" , 5 ) != 0 )"did not find magic string in file header" );if (vmaj > 1 || (vmaj == 1 && vmin > 0 )) /* Version > 1.0 */ else 0 ;if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)"unsupported version (%d.%d) in file header" ,if (AH->intSize > 32 )"sanity check on integer size (%lu) failed" ,unsigned long ) AH->intSize);if (AH->intSize > sizeof (int ))"archive was made on a machine with larger integers, some operations might fail" );if (AH->version >= K_VERS_1_7)else if (AH->format != fmt)"expected format (%d) differs from format found in file (%d)" ,if (AH->version >= K_VERS_1_15)else if (AH->version >= K_VERS_1_2)/* Guess the compression method based on the level */ if (AH->version < K_VERS_1_4)else if (AH->compression_spec.level != 0 )else if (errmsg)"archive is compressed, but this installation does not support compression (%s) -- no data will be available" ,if (AH->version >= K_VERS_1_4)struct tm crtm;/* * Newer versions of glibc have mktime ( ) report failure if tm_isdst is * inconsistent with the prevailing timezone , e . g . tm_isdst = 1 when * TZ = UTC . This is problematic when restoring an archive under a * different timezone setting . If we get a failure , try again with * tm_isdst set to - 1 ( " don ' t know " ) . * * XXX with or without this hack , we reconstruct createDate * incorrectly when the prevailing timezone is different from * pg_dump ' s . Next time we bump the archive version , we should flush * this representation and store a plain seconds - since - the - Epoch * timestamp instead . if (AH->createDate == (time_t) -1 )1 ;if (AH->createDate == (time_t) -1 )"invalid creation date in header" );if (AH->version >= K_VERS_1_4)if (AH->version >= K_VERS_1_10)/* * checkSeek * check to see if ftell / fseek can be performed . bool /* Check that ftello works on this file */ if (tpos < 0 )return false ;/* * Check that fseeko ( SEEK_SET ) works , too . NB : we used to try to test * this with fseeko ( fp , 0 , SEEK_CUR ) . But some platforms treat that as a * successful no - op even on files that are otherwise unseekable . if (fseeko(fp, tpos, SEEK_SET) != 0 )return false ;return true ;/* * dumpTimestamp static void const char *msg, time_t tim)char buf[64 ];if (strftime(buf, sizeof (buf), PGDUMP_STRFTIME_FMT, localtime(&tim)) != 0 )"-- %s %s\n\n" , msg, buf);/* * Main engine for parallel restore . * * Parallel restore is done in three phases . In this first phase , * we ' ll process all SECTION_PRE_DATA TOC entries that are allowed to be * processed in the RESTORE_PASS_MAIN pass . ( In practice , that ' s all * PRE_DATA items other than ACLs . ) Entries we can ' t process now are * added to the pending_list for later phases to deal with . static void bool skipped_some;"entering restore_toc_entries_prefork" );/* Adjust dependency information */ /* * Do all the early stuff in a single connection in the parent . There ' s no * great point in running it in parallel , in fact it will actually run * faster in a single connection because we avoid all the connection and * setup overhead . Also , pre - 9 . 2 pg_dump versions were not very good * about showing all the dependencies of SECTION_PRE_DATA items , so we do * not risk trying to process them out - of - order . * * Stuff that we can ' t do immediately gets added to the pending_list . * Note : we don ' t yet filter out entries that aren ' t going to be restored . * They might participate in dependency chains connecting entries that * should be restored , so we treat them as live until we actually process * them . * * Note : as of 9 . 2 , it should be guaranteed that all PRE_DATA items appear * before DATA items , and all DATA items before POST_DATA items . That is * not certain to be true in older archives , though , and in any case use * of a list file would destroy that ordering ( cf . SortTocFromFile ) . So * this loop cannot assume that it holds . false ;for (next_work_item = AH->toc->next; next_work_item != AH->toc; next_work_item = next_work_item->next)bool do_now = true ;if (next_work_item->section != SECTION_PRE_DATA)/* DATA and POST_DATA items are just ignored for now */ if (next_work_item->section == SECTION_DATA ||false ;true ;else /* * SECTION_NONE items , such as comments , can be processed now * if we are still in the PRE_DATA part of the archive . Once * we ' ve skipped any items , we have to consider whether the * comment ' s dependencies are satisfied , so skip it for now . if (skipped_some)false ;/* * Also skip items that need to be forced into later passes . We need * not set skipped_some in this case , since by assumption no main - pass * items could depend on these . if (_tocEntryRestorePass(next_work_item) != RESTORE_PASS_MAIN)false ;if (do_now)/* OK, restore the item and update its dependencies */ "processing item %d %s %s" ,void ) restore_toc_entry(AH, next_work_item, false );/* Reduce dependencies, but don't move anything to ready_heap */ else /* Nope, so add it to pending_list */ /* * In - - transaction - size mode , we must commit the open transaction before * dropping the database connection . This also ensures that child workers * can see the objects we ' ve created so far . if (AH->public .ropt->txn_size > 0 )public );/* * Now close parent connection in prep for parallel steps . We do this * mainly to ensure that we don ' t exceed the specified number of parallel * connections . public );/* blow away any transient state from the old connection */ /* * Main engine for parallel restore . * * Parallel restore is done in three phases . In this second phase , * we process entries by dispatching them to parallel worker children * ( processes on Unix , threads on Windows ) , each of which connects * separately to the database . Inter - entry dependencies are respected , * and so is the RestorePass multi - pass structure . When we can no longer * make any entries ready to process , we exit . Normally , there will be * nothing left to do ; but if there is , the third phase will mop up . static void "entering restore_toc_entries_parallel" );/* Set up ready_heap with enough room for all known TocEntrys */ /* * The pending_list contains all items that we need to restore . Move all * items that are available to process immediately into the ready_heap . * After this setup , the pending list is everything that needs to be done * but is blocked by one or more dependencies , while the ready heap * contains items that have no remaining dependencies and are OK to * process in the current restore pass . /* * main parent loop * * Keep going until there is no worker still running AND there is no work * left to be done . Note invariant : at top of loop , there should always * be at least one worker available to dispatch a job to . "entering main parallel loop" );for (;;)/* Look for an item ready to be dispatched to a worker */ if (next_work_item != NULL)/* If not to be restored, don't waste time launching a worker */ if ((next_work_item->reqs & (REQ_SCHEMA | REQ_DATA | REQ_STATS)) == 0 )"skipping item %d %s %s" ,/* Update its dependencies as though we'd completed it */ /* Loop around to see if anything else can be dispatched */ continue ;"launching item %d %s %s" ,/* Dispatch to some worker */ else if (IsEveryWorkerIdle(pstate))/* * Nothing is ready and no worker is running , so we ' re done with * the current pass or maybe with the whole process . if (AH->restorePass == RESTORE_PASS_LAST)break ; /* No more parallel processing is possible */ /* Advance to next restore pass */ /* That probably allows some stuff to be made ready */ /* Loop around to see if anything's now ready */ continue ;else /* * We have nothing ready , but at least one child is working , so * wait for some subjob to finish . /* * Before dispatching another job , check to see if anything has * finished . We should check every time through the loop so as to * reduce dependencies as soon as possible . If we were unable to * dispatch any job this time through , wait until some worker finishes * ( and , hopefully , unblocks some pending item ) . If we did dispatch * something , continue as soon as there ' s at least one idle worker . * Note that in either case , there ' s guaranteed to be at least one * idle worker when we return to the top of the loop . This ensures we * won ' t block inside DispatchJobForTocEntry , which would be * undesirable : we ' d rather postpone dispatching until we see what ' s * been unblocked by finished jobs . /* There should now be nothing in ready_heap. */ "finished main parallel loop" );/* * Main engine for parallel restore . * * Parallel restore is done in three phases . In this third phase , * we mop up any remaining TOC entries by processing them serially . * This phase normally should have nothing to do , but if we ' ve somehow * gotten stuck due to circular dependencies or some such , this provides * at least some chance of completing the restore successfully . static void public .ropt;"entering restore_toc_entries_postfork" );/* * Now reconnect the single parent connection . true );/* re-establish fixed state */ /* * Make sure there is no work left due to , say , circular dependencies , or * some other pathological condition . If so , do it in the single parent * connection . We don ' t sweat about RestorePass ordering ; it ' s likely we * already violated that . for (te = pending_list->pending_next; te != pending_list; te = te->pending_next)"processing missed item %d %s %s" ,void ) restore_toc_entry(AH, te, false );/* * Check if te1 has an exclusive lock requirement for an item that te2 also * requires , whether or not te2 ' s requirement is for an exclusive lock . static bool int j,for (j = 0 ; j < te1->nLockDeps; j++)for (k = 0 ; k < te2->nDeps; k++)if (te1->lockDeps[j] == te2->dependencies[k])return true ;return false ;/* * Initialize the header of the pending - items list . * * This is a circular list with a dummy TocEntry as header , just like the * main TOC list ; but we use separate list links so that an entry can be in * the main TOC list as well as in the pending list . static void /* Append te to the end of the pending-list headed by l */ static void /* Remove te from the pending-list */ static void /* qsort comparator for sorting TocEntries by dataLength */ static int const void *p1, const void *p2)const TocEntry *te1 = *(const TocEntry *const *) p1;const TocEntry *te2 = *(const TocEntry *const *) p2;/* Sort by decreasing dataLength */ if (te1->dataLength > te2->dataLength)return -1 ;if (te1->dataLength < te2->dataLength)return 1 ;/* For equal dataLengths, sort by dumpId, just to be stable */ if (te1->dumpId < te2->dumpId)return -1 ;if (te1->dumpId > te2->dumpId)return 1 ;return 0 ;/* binaryheap comparator for sorting TocEntries by dataLength */ static int void *p1, void *p2, void *arg)/* return opposite of qsort comparator for max-heap */ return -TocEntrySizeCompareQsort(&p1, &p2);/* * Move all immediately - ready items from pending_list to ready_heap . * * Items are considered ready if they have no remaining dependencies and * they belong in the current restore pass . ( See also reduce_dependencies , * which applies the same logic one - at - a - time . ) static void for (te = pending_list->pending_next; te != pending_list; te = next_te)/* must save list link before possibly removing te from list */ if (te->depCount == 0 &&/* Remove it from pending_list ... */ /* ... and add to ready_heap */ /* * Find the next work item ( if any ) that is capable of being run now , * and remove it from the ready_heap . * * Returns the item , or NULL if nothing is runnable . * * To qualify , the item must have no remaining dependencies * and no requirements for locks that are incompatible with * items currently running . Items in the ready_heap are known to have * no remaining dependencies , but we have to check for lock conflicts . static TocEntry */* * Search the ready_heap until we find a suitable item . Note that we do a * sequential scan through the heap nodes , so even though we will first * try to choose the highest - priority item , we might end up picking * something with a much lower priority . However , we expect that we will * typically be able to pick one of the first few items , which should * usually have a relatively high priority . for (int i = 0 ; i < binaryheap_size(ready_heap); i++)bool conflicts = false ;/* * Check to see if the item would need exclusive lock on something * that a currently running item also needs lock on , or vice versa . If * so , we don ' t want to schedule them together . for (int k = 0 ; k < pstate->numWorkers; k++)if (running_te == NULL)continue ;if (has_lock_conflicts(te, running_te) ||true ;break ;if (conflicts)continue ;/* passed all tests, so this item can run */ return te;"no item ready" );return NULL;/* * Restore a single TOC item in parallel with others * * this is run in the worker , i . e . in a thread ( Windows ) or a separate process * ( everything else ) . A worker process executes several such work items during * a parallel backup or restore . Once we terminate here and report back that * our work is finished , the leader process will assign us a new work item . int int status;/* Count only errors associated with this TOC entry */ public .n_errors = 0 ;/* Restore the TOC item */ true );return status;/* * Callback function that ' s invoked in the leader process after a step has * been parallel restored . * * Update status and reduce the dependency count of any dependent items . static void int status,void *callback_data)"finished item %d %s %s" ,if (status == WORKER_CREATE_DONE)else if (status == WORKER_INHIBIT_DATA)public .n_errors++;else if (status == WORKER_IGNORED_ERRORS)public .n_errors++;else if (status != 0 )"worker process failed: exit code %d" ,/* * Process the dependency information into a form useful for parallel restore . * * This function takes care of fixing up some missing or badly designed * dependencies , and then prepares subsidiary data structures that will be * used in the main parallel - restore logic , including : * 1 . We build the revDeps [ ] arrays of incoming dependency dumpIds . * 2 . We set up depCount fields that are the number of as - yet - unprocessed * dependencies for each TOC entry . * * We also identify locking dependencies so that we can avoid trying to * schedule conflicting items at the same time . static void int i;/* * Initialize the depCount / revDeps / nRevDeps fields , and make sure the TOC * items are marked as not being in any parallel - processing list . for (te = AH->toc->next; te != AH->toc; te = te->next)0 ;/* * POST_DATA items that are shown as depending on a table need to be * re - pointed to depend on that table ' s data , instead . This ensures they * won ' t get scheduled until the data has been loaded . /* * Pre - 8 . 4 versions of pg_dump neglected to set up a dependency from BLOB * COMMENTS to BLOBS . Cope . ( We assume there ' s only one BLOBS and only * one BLOB COMMENTS in such files . ) if (AH->version < K_VERS_1_11)for (te = AH->toc->next; te != AH->toc; te = te->next)if (strcmp(te->desc, "BLOB COMMENTS" ) == 0 && te->nDeps == 0 )for (te2 = AH->toc->next; te2 != AH->toc; te2 = te2->next)if (strcmp(te2->desc, "BLOBS" ) == 0 )sizeof (DumpId));0 ] = te2->dumpId;break ;break ;/* * At this point we start to build the revDeps reverse - dependency arrays , * so all changes of dependencies must be complete . /* * Count the incoming dependencies for each item . Also , it is possible * that the dependencies list items that are not in the archive at all * ( that should not happen in 9 . 2 and later , but is highly likely in older * archives ) . Subtract such items from the depCounts . for (te = AH->toc->next; te != AH->toc; te = te->next)for (i = 0 ; i < te->nDeps; i++)if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL)else /* * Allocate space for revDeps [ ] arrays , and reset nRevDeps so we can use * it as a counter below . for (te = AH->toc->next; te != AH->toc; te = te->next)if (te->nRevDeps > 0 )sizeof (DumpId));0 ;/* * Build the revDeps [ ] arrays of incoming - dependency dumpIds . This had * better agree with the loops above . for (te = AH->toc->next; te != AH->toc; te = te->next)for (i = 0 ; i < te->nDeps; i++)if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL)/* * Lastly , work out the locking dependencies . for (te = AH->toc->next; te != AH->toc; te = te->next)0 ;/* * Change dependencies on table items to depend on table data items instead , * but only in POST_DATA items . * * Also , for any item having such dependency ( s ) , set its dataLength to the * largest dataLength of the table data items it depends on . This ensures * that parallel restore will prioritize larger jobs ( index builds , FK * constraint checks , etc ) over smaller ones , avoiding situations where we * end a restore with only one active job working on a large table . static void int i;for (te = AH->toc->next; te != AH->toc; te = te->next)if (te->section != SECTION_POST_DATA)continue ;for (i = 0 ; i < te->nDeps; i++)if (olddep <= AH->maxDumpId &&0 )"transferring dependency %d -> %d to %d" ,/* * Identify which objects we ' ll need exclusive lock on in order to restore * the given TOC entry ( * other * than the one identified by the TOC entry * itself ) . Record their dump IDs in the entry ' s lockDeps [ ] array . static void int nlockids;int i;/* * We only care about this for POST_DATA items . PRE_DATA items are not * run in parallel , and DATA items are all independent by assumption . if (te->section != SECTION_POST_DATA)return ;/* Quick exit if no dependencies at all */ if (te->nDeps == 0 )return ;/* * Most POST_DATA items are ALTER TABLEs or some moral equivalent of that , * and hence require exclusive lock . However , we know that CREATE INDEX * does not . ( Maybe someday index - creating CONSTRAINTs will fall in that * category too . . . but today is not that day . ) if (strcmp(te->desc, "INDEX" ) == 0 )return ;/* * We assume the entry requires exclusive lock on each TABLE or TABLE DATA * item listed among its dependencies . Originally all of these would have * been TABLE items , but repoint_table_dependencies would have repointed * them to the TABLE DATA items if those are present ( which they might not * be , eg in a schema - only dump ) . Note that all of the entries we are * processing here are POST_DATA ; otherwise there might be a significant * difference between a dependency on a table and a dependency on its * data , so that closer analysis would be needed here . sizeof (DumpId));0 ;for (i = 0 ; i < te->nDeps; i++)if (depid <= AH->maxDumpId && AH->tocsByDumpId[depid] != NULL &&"TABLE DATA" ) == 0 ) ||"TABLE" ) == 0 ))if (nlockids == 0 )return ;sizeof (DumpId));/* * Remove the specified TOC entry from the depCounts of items that depend on * it , thereby possibly making them ready - to - run . Any pending item that * becomes ready should be moved to the ready_heap , if that ' s provided . static void int i;"reducing dependencies for %d" , te->dumpId);for (i = 0 ; i < te->nRevDeps; i++)0 );/* * It ' s ready if it has no remaining dependencies , and it belongs in * the current restore pass , and it is currently a member of the * pending list ( that check is needed to prevent double restore in * some cases where a list - file forces out - of - order restoring ) . * However , if ready_heap = = NULL then caller doesn ' t want any list * memberships changed . if (otherte->depCount == 0 &&/* Remove it from pending list ... */ /* ... and add to ready_heap */ /* * Set the created flag on the DATA member corresponding to the given * TABLE member static void if (AH->tableDataId[te->dumpId] != 0 )true ;/* * Mark the DATA member corresponding to the given TABLE member * as not wanted static void "table \" %s\" could not be created, will not restore its data" ,if (AH->tableDataId[te->dumpId] != 0 )0 ;/* * Clone and de - clone routines used in parallel restoration . * * Enough of the structure is cloned to ensure that there is no * conflict between different threads each with their own clone . /* Make a "flat" copy */ sizeof (ArchiveHandle));sizeof (ArchiveHandle));/* Likewise flat-copy the RestoreOptions, so we can alter them locally */ public .ropt = (RestoreOptions *) pg_malloc(sizeof (RestoreOptions));public .ropt, AH->public .ropt, sizeof (RestoreOptions));/* Handle format-independent fields */ 0 , sizeof (clone->sqlparse));/* The clone will have its own connection, so disregard connection state */ /* savedPassword must be local in case we change it while connecting */ if (clone->savedPassword)/* clone has its own error count, too */ public .n_errors = 0 ;/* clones should not share lo_buf */ /* * Clone connections disregard - - transaction - size ; they must commit after * each command so that the results are immediately visible to other * workers . public .ropt->txn_size = 0 ;/* * Connect our new clone object to the database , using the same connection * parameters used for the original connection . public .ropt->cparams, true );/* re-establish fixed state */ if (AH->mode == archModeRead)/* in write case, setupDumpWorker will fix up connection state */ /* Let the format-specific code have a chance too */ return clone;/* * Release clone - local storage . * * Note : we assume any clone - local connection was already closed . void /* Should not have an open database connection */ /* Clear format-specific state */ /* Clear state allocated by CloneArchive */ if (AH->sqlparse.curCmd)/* Clear any connection-local state */
Messung V0.5 in Prozent C=93 H=94 G=93
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.161Bemerkung:
(vorverarbeitet am 2026-08-07)
¤ *Bot Zugriff
