diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 5fde18921ac3c20f878fbe5ad22c60fabc13a916..71cc3416bb9fd9dcf482c7e8c3a99d01acd7f238 100644 *** a/src/bin/pg_dump/pg_dump.c --- b/src/bin/pg_dump/pg_dump.c *************** static void dumpACL(Archive *fout, Catal *** 210,215 **** --- 210,220 ---- const char *acls); static void getDependencies(Archive *fout); + + static DumpableObject *createBoundaryObjects(void); + static void addBoundaryDependencies(DumpableObject **dobjs, int numObjs, + DumpableObject *boundaryObjs); + static void getDomainConstraints(Archive *fout, TypeInfo *tyinfo); static void getTableData(TableInfo *tblinfo, int numTables, bool oids); static void makeTableDataInfo(TableInfo *tbinfo, bool oids); *************** main(int argc, char **argv) *** 270,275 **** --- 275,281 ---- int numTables; DumpableObject **dobjs; int numObjs; + DumpableObject *boundaryObjs; int i; enum trivalue prompt_password = TRI_DEFAULT; int compressLevel = -1; *************** main(int argc, char **argv) *** 691,696 **** --- 697,713 ---- */ getDependencies(fout); + /* Lastly, create dummy objects to represent the section boundaries */ + boundaryObjs = createBoundaryObjects(); + + /* Get pointers to all the known DumpableObjects */ + getDumpableObjects(&dobjs, &numObjs); + + /* + * Add dummy dependencies to enforce the dump section ordering. + */ + addBoundaryDependencies(dobjs, numObjs, boundaryObjs); + /* * Sort the objects into a safe dump order (no forward references). * *************** main(int argc, char **argv) *** 700,713 **** * will dump identically. Before 7.3 we don't have dependencies and we * use OID ordering as an (unreliable) guide to creation order. */ - getDumpableObjects(&dobjs, &numObjs); - if (fout->remoteVersion >= 70300) sortDumpableObjectsByTypeName(dobjs, numObjs); else sortDumpableObjectsByTypeOid(dobjs, numObjs); ! sortDumpableObjects(dobjs, numObjs); /* * Create archive TOC entries for all the objects to be dumped, in a safe --- 717,729 ---- * will dump identically. Before 7.3 we don't have dependencies and we * use OID ordering as an (unreliable) guide to creation order. */ if (fout->remoteVersion >= 70300) sortDumpableObjectsByTypeName(dobjs, numObjs); else sortDumpableObjectsByTypeOid(dobjs, numObjs); ! sortDumpableObjects(dobjs, numObjs, ! boundaryObjs[0].dumpId, boundaryObjs[1].dumpId); /* * Create archive TOC entries for all the objects to be dumped, in a safe *************** dumpDumpableObject(Archive *fout, Dumpab *** 7184,7189 **** --- 7200,7209 ---- dobj->dependencies, dobj->nDeps, dumpBlobs, NULL); break; + case DO_PRE_DATA_BOUNDARY: + case DO_POST_DATA_BOUNDARY: + /* never dumped, nothing to do */ + break; } } *************** dumpDefaultACL(Archive *fout, DefaultACL *** 11672,11678 **** daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL, NULL, daclinfo->defaclrole, ! false, "DEFAULT ACL", SECTION_NONE, q->data, "", NULL, daclinfo->dobj.dependencies, daclinfo->dobj.nDeps, NULL, NULL); --- 11692,11698 ---- daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL, NULL, daclinfo->defaclrole, ! false, "DEFAULT ACL", SECTION_POST_DATA, q->data, "", NULL, daclinfo->dobj.dependencies, daclinfo->dobj.nDeps, NULL, NULL); *************** getDependencies(Archive *fout) *** 14028,14033 **** --- 14048,14160 ---- /* + * createBoundaryObjects - create dummy DumpableObjects to represent + * dump section boundaries. + */ + static DumpableObject * + createBoundaryObjects(void) + { + DumpableObject *dobjs; + + dobjs = (DumpableObject *) pg_malloc(2 * sizeof(DumpableObject)); + + dobjs[0].objType = DO_PRE_DATA_BOUNDARY; + dobjs[0].catId = nilCatalogId; + AssignDumpId(dobjs + 0); + dobjs[0].name = pg_strdup("PRE-DATA BOUNDARY"); + + dobjs[1].objType = DO_POST_DATA_BOUNDARY; + dobjs[1].catId = nilCatalogId; + AssignDumpId(dobjs + 1); + dobjs[1].name = pg_strdup("POST-DATA BOUNDARY"); + + return dobjs; + } + + /* + * addBoundaryDependencies - add dependencies as needed to enforce the dump + * section boundaries. + */ + static void + addBoundaryDependencies(DumpableObject **dobjs, int numObjs, + DumpableObject *boundaryObjs) + { + DumpableObject *preDataBound = boundaryObjs + 0; + DumpableObject *postDataBound = boundaryObjs + 1; + int i; + + for (i = 0; i < numObjs; i++) + { + DumpableObject *dobj = dobjs[i]; + + /* + * The classification of object types here must match the SECTION_xxx + * values assigned during subsequent ArchiveEntry calls! + */ + switch (dobj->objType) + { + case DO_NAMESPACE: + case DO_EXTENSION: + case DO_TYPE: + case DO_SHELL_TYPE: + case DO_FUNC: + case DO_AGG: + case DO_OPERATOR: + case DO_OPCLASS: + case DO_OPFAMILY: + case DO_COLLATION: + case DO_CONVERSION: + case DO_TABLE: + case DO_ATTRDEF: + case DO_PROCLANG: + case DO_CAST: + case DO_DUMMY_TYPE: + case DO_TSPARSER: + case DO_TSDICT: + case DO_TSTEMPLATE: + case DO_TSCONFIG: + case DO_FDW: + case DO_FOREIGN_SERVER: + case DO_BLOB: + /* Pre-data objects: must come before the pre-data boundary */ + addObjectDependency(preDataBound, dobj->dumpId); + break; + case DO_TABLE_DATA: + case DO_BLOB_DATA: + /* Data objects: must come between the boundaries */ + addObjectDependency(dobj, preDataBound->dumpId); + addObjectDependency(postDataBound, dobj->dumpId); + break; + case DO_INDEX: + case DO_TRIGGER: + case DO_DEFAULT_ACL: + /* Post-data objects: must come after the post-data boundary */ + addObjectDependency(dobj, postDataBound->dumpId); + break; + case DO_RULE: + /* Rules are post-data, but only if dumped separately */ + if (((RuleInfo *) dobj)->separate) + addObjectDependency(dobj, postDataBound->dumpId); + break; + case DO_CONSTRAINT: + case DO_FK_CONSTRAINT: + /* Constraints are post-data, but only if dumped separately */ + if (((ConstraintInfo *) dobj)->separate) + addObjectDependency(dobj, postDataBound->dumpId); + break; + case DO_PRE_DATA_BOUNDARY: + /* nothing to do */ + break; + case DO_POST_DATA_BOUNDARY: + /* must come after the pre-data boundary */ + addObjectDependency(dobj, preDataBound->dumpId); + break; + } + } + } + + + /* * selectSourceSchema - make the specified schema the active search path * in the source database. * diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h index f26d8d3ab66e3d4e894f96cdf0f33aa739050e7e..b44187bbdcfc3a809b32059a00966b09581cd2a3 100644 *** a/src/bin/pg_dump/pg_dump.h --- b/src/bin/pg_dump/pg_dump.h *************** typedef enum *** 97,102 **** --- 97,103 ---- DO_OPERATOR, DO_OPCLASS, DO_OPFAMILY, + DO_COLLATION, DO_CONVERSION, DO_TABLE, DO_ATTRDEF, *************** typedef enum *** 118,124 **** DO_DEFAULT_ACL, DO_BLOB, DO_BLOB_DATA, ! DO_COLLATION } DumpableObjectType; typedef struct _dumpableObject --- 119,126 ---- DO_DEFAULT_ACL, DO_BLOB, DO_BLOB_DATA, ! DO_PRE_DATA_BOUNDARY, ! DO_POST_DATA_BOUNDARY } DumpableObjectType; typedef struct _dumpableObject *************** extern bool simple_string_list_member(Si *** 520,526 **** extern void parseOidArray(const char *str, Oid *array, int arraysize); ! extern void sortDumpableObjects(DumpableObject **objs, int numObjs); extern void sortDumpableObjectsByTypeName(DumpableObject **objs, int numObjs); extern void sortDumpableObjectsByTypeOid(DumpableObject **objs, int numObjs); --- 522,529 ---- extern void parseOidArray(const char *str, Oid *array, int arraysize); ! extern void sortDumpableObjects(DumpableObject **objs, int numObjs, ! DumpId preBoundaryId, DumpId postBoundaryId); extern void sortDumpableObjectsByTypeName(DumpableObject **objs, int numObjs); extern void sortDumpableObjectsByTypeOid(DumpableObject **objs, int numObjs); diff --git a/src/bin/pg_dump/pg_dump_sort.c b/src/bin/pg_dump/pg_dump_sort.c index 9a82e4b6c58a6d22f6785d261ddf9fe1a8c34e96..9aa69052d492872f09b990faa088d4cedb882a7b 100644 *** a/src/bin/pg_dump/pg_dump_sort.c --- b/src/bin/pg_dump/pg_dump_sort.c *************** static const char *modulename = gettext_ *** 26,31 **** --- 26,36 ---- * behavior for old databases without full dependency info.) Note: collations, * extensions, text search, foreign-data, and default ACL objects can't really * happen here, so the rather bogus priorities for them don't matter. + * + * NOTE: object-type priorities must match the section assignments made in + * pg_dump.c; that is, PRE_DATA objects must sort before DO_PRE_DATA_BOUNDARY, + * POST_DATA objects must sort after DO_POST_DATA_BOUNDARY, and DATA objects + * must sort between them. */ static const int oldObjectTypePriority[] = { *************** static const int oldObjectTypePriority[] *** 38,70 **** 3, /* DO_OPERATOR */ 4, /* DO_OPCLASS */ 4, /* DO_OPFAMILY */ 5, /* DO_CONVERSION */ 6, /* DO_TABLE */ 8, /* DO_ATTRDEF */ ! 13, /* DO_INDEX */ ! 14, /* DO_RULE */ ! 15, /* DO_TRIGGER */ ! 12, /* DO_CONSTRAINT */ ! 16, /* DO_FK_CONSTRAINT */ 2, /* DO_PROCLANG */ 2, /* DO_CAST */ ! 10, /* DO_TABLE_DATA */ 7, /* DO_DUMMY_TYPE */ ! 3, /* DO_TSPARSER */ 4, /* DO_TSDICT */ ! 3, /* DO_TSTEMPLATE */ ! 5, /* DO_TSCONFIG */ ! 3, /* DO_FDW */ 4, /* DO_FOREIGN_SERVER */ ! 17, /* DO_DEFAULT_ACL */ 9, /* DO_BLOB */ ! 11, /* DO_BLOB_DATA */ ! 2 /* DO_COLLATION */ }; /* * Sort priority for object types when dumping newer databases. * Objects are sorted by type, and within a type by name. */ static const int newObjectTypePriority[] = { --- 43,82 ---- 3, /* DO_OPERATOR */ 4, /* DO_OPCLASS */ 4, /* DO_OPFAMILY */ + 4, /* DO_COLLATION */ 5, /* DO_CONVERSION */ 6, /* DO_TABLE */ 8, /* DO_ATTRDEF */ ! 15, /* DO_INDEX */ ! 16, /* DO_RULE */ ! 17, /* DO_TRIGGER */ ! 14, /* DO_CONSTRAINT */ ! 18, /* DO_FK_CONSTRAINT */ 2, /* DO_PROCLANG */ 2, /* DO_CAST */ ! 11, /* DO_TABLE_DATA */ 7, /* DO_DUMMY_TYPE */ ! 4, /* DO_TSPARSER */ 4, /* DO_TSDICT */ ! 4, /* DO_TSTEMPLATE */ ! 4, /* DO_TSCONFIG */ ! 4, /* DO_FDW */ 4, /* DO_FOREIGN_SERVER */ ! 19, /* DO_DEFAULT_ACL */ 9, /* DO_BLOB */ ! 12, /* DO_BLOB_DATA */ ! 10, /* DO_PRE_DATA_BOUNDARY */ ! 13 /* DO_POST_DATA_BOUNDARY */ }; /* * Sort priority for object types when dumping newer databases. * Objects are sorted by type, and within a type by name. + * + * NOTE: object-type priorities must match the section assignments made in + * pg_dump.c; that is, PRE_DATA objects must sort before DO_PRE_DATA_BOUNDARY, + * POST_DATA objects must sort after DO_POST_DATA_BOUNDARY, and DATA objects + * must sort between them. */ static const int newObjectTypePriority[] = { *************** static const int newObjectTypePriority[] *** 77,93 **** 8, /* DO_OPERATOR */ 9, /* DO_OPCLASS */ 9, /* DO_OPFAMILY */ 11, /* DO_CONVERSION */ 18, /* DO_TABLE */ 20, /* DO_ATTRDEF */ ! 25, /* DO_INDEX */ ! 26, /* DO_RULE */ ! 27, /* DO_TRIGGER */ ! 24, /* DO_CONSTRAINT */ ! 28, /* DO_FK_CONSTRAINT */ 2, /* DO_PROCLANG */ 10, /* DO_CAST */ ! 22, /* DO_TABLE_DATA */ 19, /* DO_DUMMY_TYPE */ 12, /* DO_TSPARSER */ 14, /* DO_TSDICT */ --- 89,106 ---- 8, /* DO_OPERATOR */ 9, /* DO_OPCLASS */ 9, /* DO_OPFAMILY */ + 3, /* DO_COLLATION */ 11, /* DO_CONVERSION */ 18, /* DO_TABLE */ 20, /* DO_ATTRDEF */ ! 27, /* DO_INDEX */ ! 28, /* DO_RULE */ ! 29, /* DO_TRIGGER */ ! 26, /* DO_CONSTRAINT */ ! 30, /* DO_FK_CONSTRAINT */ 2, /* DO_PROCLANG */ 10, /* DO_CAST */ ! 23, /* DO_TABLE_DATA */ 19, /* DO_DUMMY_TYPE */ 12, /* DO_TSPARSER */ 14, /* DO_TSDICT */ *************** static const int newObjectTypePriority[] *** 95,106 **** 15, /* DO_TSCONFIG */ 16, /* DO_FDW */ 17, /* DO_FOREIGN_SERVER */ ! 29, /* DO_DEFAULT_ACL */ 21, /* DO_BLOB */ ! 23, /* DO_BLOB_DATA */ ! 3 /* DO_COLLATION */ }; static int DOTypeNameCompare(const void *p1, const void *p2); static int DOTypeOidCompare(const void *p1, const void *p2); --- 108,123 ---- 15, /* DO_TSCONFIG */ 16, /* DO_FDW */ 17, /* DO_FOREIGN_SERVER */ ! 31, /* DO_DEFAULT_ACL */ 21, /* DO_BLOB */ ! 24, /* DO_BLOB_DATA */ ! 22, /* DO_PRE_DATA_BOUNDARY */ ! 25 /* DO_POST_DATA_BOUNDARY */ }; + static DumpId preDataBoundId; + static DumpId postDataBoundId; + static int DOTypeNameCompare(const void *p1, const void *p2); static int DOTypeOidCompare(const void *p1, const void *p2); *************** DOTypeOidCompare(const void *p1, const v *** 237,252 **** /* * Sort the given objects into a safe dump order using dependency * information (to the extent we have it available). */ void ! sortDumpableObjects(DumpableObject **objs, int numObjs) { DumpableObject **ordering; int nOrdering; ! if (numObjs <= 0) return; ordering = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *)); while (!TopoSort(objs, numObjs, ordering, &nOrdering)) findDependencyLoops(ordering, nOrdering, numObjs); --- 254,280 ---- /* * Sort the given objects into a safe dump order using dependency * information (to the extent we have it available). + * + * The DumpIds of the PRE_DATA_BOUNDARY and POST_DATA_BOUNDARY objects are + * passed in separately, in case we need them during dependency loop repair. */ void ! sortDumpableObjects(DumpableObject **objs, int numObjs, ! DumpId preBoundaryId, DumpId postBoundaryId) { DumpableObject **ordering; int nOrdering; ! if (numObjs <= 0) /* can't happen anymore ... */ return; + /* + * Saving the boundary IDs in static variables is a bit grotty, but seems + * better than adding them to parameter lists of subsidiary functions. + */ + preDataBoundId = preBoundaryId; + postDataBoundId = postBoundaryId; + ordering = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *)); while (!TopoSort(objs, numObjs, ordering, &nOrdering)) findDependencyLoops(ordering, nOrdering, numObjs); *************** repairViewRuleMultiLoop(DumpableObject * *** 701,706 **** --- 729,736 ---- ((RuleInfo *) ruleobj)->separate = true; /* put back rule's dependency on view */ addObjectDependency(ruleobj, viewobj->dumpId); + /* now that rule is separate, it must be post-data */ + addObjectDependency(ruleobj, postDataBoundId); } /* *************** repairTableConstraintMultiLoop(DumpableO *** 736,741 **** --- 766,773 ---- ((ConstraintInfo *) constraintobj)->separate = true; /* put back constraint's dependency on table */ addObjectDependency(constraintobj, tableobj->dumpId); + /* now that constraint is separate, it must be post-data */ + addObjectDependency(constraintobj, postDataBoundId); } /* *************** repairDomainConstraintMultiLoop(Dumpable *** 782,787 **** --- 814,821 ---- ((ConstraintInfo *) constraintobj)->separate = true; /* put back constraint's dependency on domain */ addObjectDependency(constraintobj, domainobj->dumpId); + /* now that constraint is separate, it must be post-data */ + addObjectDependency(constraintobj, postDataBoundId); } /* *************** describeDumpableObject(DumpableObject *o *** 1190,1195 **** --- 1224,1239 ---- "BLOB DATA (ID %d)", obj->dumpId); return; + case DO_PRE_DATA_BOUNDARY: + snprintf(buf, bufsize, + "PRE-DATA BOUNDARY (ID %d)", + obj->dumpId); + return; + case DO_POST_DATA_BOUNDARY: + snprintf(buf, bufsize, + "POST-DATA BOUNDARY (ID %d)", + obj->dumpId); + return; } /* shouldn't get here */ snprintf(buf, bufsize,