#include "postgres_fe.h"
#include <ctype.h>
#include "catalog/pg_class_d.h"
#include "fe_utils/string_utils.h"
#include "pg_backup_archiver.h"
#include "pg_backup_utils.h"
#include "pg_dump.h"

Include dependency graph for common.c:

Functions
static void	flagInhTables (Archive fout, TableInfo tbinfo, int numTables, InhInfo *inhinfo, int numInherits)

static void	flagInhIndexes (Archive fout, TableInfo tblinfo, int numTables)

static void	flagInhAttrs (DumpOptions dopt, TableInfo tblinfo, int numTables)

static DumpableObject **	buildIndexArray (void *objArray, int numObjs, Size objSize)

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

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

static void	findParentsByOid (TableInfo self, InhInfo inhinfo, int numInherits)

static int	strInArray (const char pattern, char *arr, int arr_size)

static IndxInfo *	findIndexByOid (Oid oid, DumpableObject **idxinfoindex, int numIndexes)

TableInfo *	getSchemaData (Archive fout, int numTablesPtr)

static void	flagInhIndexes (Archive *fout, TableInfo tblinfo[], int numTables)

void	AssignDumpId (DumpableObject *dobj)

DumpId	createDumpId (void)

DumpId	getMaxDumpId (void)

DumpableObject *	findObjectByDumpId (DumpId dumpId)

DumpableObject *	findObjectByCatalogId (CatalogId catalogId)

static DumpableObject *	findObjectByOid (Oid oid, DumpableObject **indexArray, int numObjs)

void	getDumpableObjects (DumpableObject **objs, int numObjs)

void	addObjectDependency (DumpableObject *dobj, DumpId refId)

void	removeObjectDependency (DumpableObject *dobj, DumpId refId)

TableInfo *	findTableByOid (Oid oid)

TypeInfo *	findTypeByOid (Oid oid)

FuncInfo *	findFuncByOid (Oid oid)

OprInfo *	findOprByOid (Oid oid)

CollInfo *	findCollationByOid (Oid oid)

NamespaceInfo *	findNamespaceByOid (Oid oid)

ExtensionInfo *	findExtensionByOid (Oid oid)

PublicationInfo *	findPublicationByOid (Oid oid)

void	setExtensionMembership (ExtensionMemberId *extmems, int nextmems)

ExtensionInfo *	findOwningExtension (CatalogId catalogId)

void	parseOidArray (const char str, Oid array, int arraysize)

Variables
static DumpableObject **	dumpIdMap = NULL

static int	allocedDumpIds = 0

static DumpId	lastDumpId = 0

static bool	catalogIdMapValid = false

static DumpableObject **	catalogIdMap = NULL

static int	numCatalogIds = 0

static DumpableObject **	tblinfoindex

static DumpableObject **	typinfoindex

static DumpableObject **	funinfoindex

static DumpableObject **	oprinfoindex

static DumpableObject **	collinfoindex

static DumpableObject **	nspinfoindex

static DumpableObject **	extinfoindex

static DumpableObject **	pubinfoindex

static int	numTables

static int	numTypes

static int	numFuncs

static int	numOperators

static int	numCollations

static int	numNamespaces

static int	numExtensions

static int	numPublications

static ExtensionMemberId *	extmembers

static int	numextmembers

Function Documentation

◆ addObjectDependency()

void addObjectDependency	(	DumpableObject *	dobj,
		DumpId	refId
	)

Definition at line 846 of file common.c.

References _dumpableObject::allocDeps, _dumpableObject::dependencies, _dumpableObject::nDeps, pg_malloc(), and pg_realloc().

Referenced by addBoundaryDependencies(), addConstrChildIdxDeps(), buildMatViewRefreshDependencies(), checkExtensionMembership(), flagInhAttrs(), flagInhIndexes(), flagInhTables(), getDependencies(), getDomainConstraints(), getRules(), getTableAttrs(), getTableDataFKConstraints(), makeTableDataInfo(), processExtensionTables(), repairDomainConstraintMultiLoop(), repairTableAttrDefMultiLoop(), repairTableConstraintMultiLoop(), repairTypeFuncLoop(), and repairViewRuleMultiLoop().

 {
     if (dobj->nDeps >= dobj->allocDeps)
     {
         if (dobj->allocDeps <= 0)
         {
             dobj->allocDeps = 16;
             dobj->dependencies = (DumpId *)
                 pg_malloc(dobj->allocDeps * sizeof(DumpId));
         }
         else
         {
             dobj->allocDeps *= 2;
             dobj->dependencies = (DumpId *)
                 pg_realloc(dobj->dependencies,
                            dobj->allocDeps * sizeof(DumpId));
         }
     }
     dobj->dependencies[dobj->nDeps++] = refId;
 }

◆ AssignDumpId()

void AssignDumpId ( DumpableObject * dobj )

Definition at line 605 of file common.c.

References _dumpableObject::allocDeps, allocedDumpIds, catalogIdMapValid, _dumpableObject::dependencies, _dumpableObject::depends_on_ext, _dumpableObject::dump, DUMP_COMPONENT_ALL, _dumpableObject::dump_contains, _dumpableObject::dumpId, _dumpableObject::ext_member, lastDumpId, _dumpableObject::name, _dumpableObject::nDeps, pg_malloc(), and pg_realloc().

Referenced by createBoundaryObjects(), flagInhAttrs(), flagInhIndexes(), flagInhTables(), getAccessMethods(), getAggregates(), getBlobs(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPolicies(), getProcLangs(), getPublications(), getPublicationTables(), getRules(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), and makeTableDataInfo().

 {
     dobj->dumpId = ++lastDumpId;
     dobj->name = NULL;          /* must be set later */
     dobj->namespace = NULL;     /* may be set later */
     dobj->dump = DUMP_COMPONENT_ALL;    /* default assumption */
     dobj->dump_contains = DUMP_COMPONENT_ALL;   /* default assumption */
     dobj->ext_member = false;   /* default assumption */
     dobj->depends_on_ext = false;   /* default assumption */
     dobj->dependencies = NULL;
     dobj->nDeps = 0;
     dobj->allocDeps = 0;
 
     while (dobj->dumpId >= allocedDumpIds)
     {
         int         newAlloc;
 
         if (allocedDumpIds <= 0)
         {
             newAlloc = 256;
             dumpIdMap = (DumpableObject **)
                 pg_malloc(newAlloc * sizeof(DumpableObject *));
         }
         else
         {
             newAlloc = allocedDumpIds * 2;
             dumpIdMap = (DumpableObject **)
                 pg_realloc(dumpIdMap, newAlloc * sizeof(DumpableObject *));
         }
         memset(dumpIdMap + allocedDumpIds, 0,
                (newAlloc - allocedDumpIds) * sizeof(DumpableObject *));
         allocedDumpIds = newAlloc;
     }
     dumpIdMap[dobj->dumpId] = dobj;
 
     /* mark catalogIdMap invalid, but don't rebuild it yet */
     catalogIdMapValid = false;
 }

◆ buildIndexArray()

static DumpableObject ** buildIndexArray	(	void *	objArray,
		int	numObjs,
		Size	objSize
	)

static

Definition at line 778 of file common.c.

References DOCatalogIdCompare(), i, pg_malloc(), and qsort.

Referenced by flagInhIndexes(), and getSchemaData().

 {
     DumpableObject **ptrs;
     int         i;
 
     if (numObjs <= 0)
         return NULL;
 
     ptrs = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *));
     for (i = 0; i < numObjs; i++)
         ptrs[i] = (DumpableObject *) ((char *) objArray + i * objSize);
 
     /* We can use DOCatalogIdCompare to sort since its first key is OID */
     if (numObjs > 1)
         qsort((void *) ptrs, numObjs, sizeof(DumpableObject *),
               DOCatalogIdCompare);
 
     return ptrs;
 }

◆ createDumpId()

DumpId createDumpId ( void )

Definition at line 651 of file common.c.

References lastDumpId.

Referenced by dumpACL(), dumpCommentExtended(), dumpCompositeTypeColComments(), dumpDatabase(), dumpEncoding(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpStdStrings(), dumpTableComment(), dumpTableSecLabel(), and dumpUserMappings().

 {
     return ++lastDumpId;
 }

◆ DOCatalogIdCompare()

static int DOCatalogIdCompare	(	const void *	p1,
		const void *	p2
	)

static

Definition at line 802 of file common.c.

References _dumpableObject::catId, CatalogId::oid, oidcmp, and CatalogId::tableoid.

Referenced by buildIndexArray(), and findObjectByCatalogId().

 {
     const DumpableObject *obj1 = *(DumpableObject *const *) p1;
     const DumpableObject *obj2 = *(DumpableObject *const *) p2;
     int         cmpval;
 
     /*
      * Compare OID first since it's usually unique, whereas there will only be
      * a few distinct values of tableoid.
      */
     cmpval = oidcmp(obj1->catId.oid, obj2->catId.oid);
     if (cmpval == 0)
         cmpval = oidcmp(obj1->catId.tableoid, obj2->catId.tableoid);
     return cmpval;
 }

◆ ExtensionMemberIdCompare()

static int ExtensionMemberIdCompare	(	const void *	p1,
		const void *	p2
	)

static

Definition at line 1047 of file common.c.

References _extensionMemberId::catId, CatalogId::oid, oidcmp, and CatalogId::tableoid.

Referenced by setExtensionMembership().

 {
     const ExtensionMemberId *obj1 = (const ExtensionMemberId *) p1;
     const ExtensionMemberId *obj2 = (const ExtensionMemberId *) p2;
     int         cmpval;
 
     /*
      * Compare OID first since it's usually unique, whereas there will only be
      * a few distinct values of tableoid.
      */
     cmpval = oidcmp(obj1->catId.oid, obj2->catId.oid);
     if (cmpval == 0)
         cmpval = oidcmp(obj1->catId.tableoid, obj2->catId.tableoid);
     return cmpval;
 }

◆ findCollationByOid()

CollInfo* findCollationByOid ( Oid oid )

Definition at line 937 of file common.c.

References findObjectByOid(), and numCollations.

Referenced by createDummyViewAsClause(), dumpCompositeType(), dumpDomain(), dumpRangeType(), and dumpTableSchema().

 {
     return (CollInfo *) findObjectByOid(oid, collinfoindex, numCollations);
 }

◆ findExtensionByOid()

ExtensionInfo* findExtensionByOid ( Oid oid )

Definition at line 959 of file common.c.

References findObjectByOid(), and numExtensions.

Referenced by getExtensionMembership().

 {
     return (ExtensionInfo *) findObjectByOid(oid, extinfoindex, numExtensions);
 }

◆ findFuncByOid()

FuncInfo* findFuncByOid ( Oid oid )

Definition at line 915 of file common.c.

References findObjectByOid(), and numFuncs.

Referenced by dumpCast(), dumpProcLang(), and dumpTransform().

 {
     return (FuncInfo *) findObjectByOid(oid, funinfoindex, numFuncs);
 }

◆ findIndexByOid()

static IndxInfo * findIndexByOid	(	Oid	oid,
		DumpableObject **	idxinfoindex,
		int	numIndexes
	)

static

Definition at line 983 of file common.c.

References findObjectByOid().

Referenced by flagInhIndexes().

 {
     return (IndxInfo *) findObjectByOid(oid, idxinfoindex, numIndexes);
 }

◆ findNamespaceByOid()

NamespaceInfo* findNamespaceByOid ( Oid oid )

Definition at line 948 of file common.c.

References findObjectByOid(), and numNamespaces.

Referenced by findNamespace().

 {
     return (NamespaceInfo *) findObjectByOid(oid, nspinfoindex, numNamespaces);
 }

◆ findObjectByCatalogId()

DumpableObject* findObjectByCatalogId ( CatalogId catalogId )

Definition at line 689 of file common.c.

References catalogIdMap, catalogIdMapValid, difference(), DOCatalogIdCompare(), free, getDumpableObjects(), numCatalogIds, CatalogId::oid, oidcmp, qsort, and CatalogId::tableoid.

Referenced by buildMatViewRefreshDependencies(), and getDependencies().

 {
     DumpableObject **low;
     DumpableObject **high;
 
     if (!catalogIdMapValid)
     {
         if (catalogIdMap)
             free(catalogIdMap);
         getDumpableObjects(&catalogIdMap, &numCatalogIds);
         if (numCatalogIds > 1)
             qsort((void *) catalogIdMap, numCatalogIds,
                   sizeof(DumpableObject *), DOCatalogIdCompare);
         catalogIdMapValid = true;
     }
 
     /*
      * We could use bsearch() here, but the notational cruft of calling
      * bsearch is nearly as bad as doing it ourselves; and the generalized
      * bsearch function is noticeably slower as well.
      */
     if (numCatalogIds <= 0)
         return NULL;
     low = catalogIdMap;
     high = catalogIdMap + (numCatalogIds - 1);
     while (low <= high)
     {
         DumpableObject **middle;
         int         difference;
 
         middle = low + (high - low) / 2;
         /* comparison must match DOCatalogIdCompare, below */
         difference = oidcmp((*middle)->catId.oid, catalogId.oid);
         if (difference == 0)
             difference = oidcmp((*middle)->catId.tableoid, catalogId.tableoid);
         if (difference == 0)
             return *middle;
         else if (difference < 0)
             low = middle + 1;
         else
             high = middle - 1;
     }
     return NULL;
 }

◆ findObjectByDumpId()

DumpableObject* findObjectByDumpId ( DumpId dumpId )

Definition at line 671 of file common.c.

References allocedDumpIds.

Referenced by binary_upgrade_extension_member(), BuildArchiveDependencies(), dumpConstraint(), dumpExtension(), findDumpableDependencies(), and findLoop().

 {
     if (dumpId <= 0 || dumpId >= allocedDumpIds)
         return NULL;            /* out of range? */
     return dumpIdMap[dumpId];
 }

◆ findObjectByOid()

static DumpableObject* findObjectByOid	(	Oid	oid,
		DumpableObject **	indexArray,
		int	numObjs
	)

static

Definition at line 740 of file common.c.

References difference(), and oidcmp.

Referenced by findCollationByOid(), findExtensionByOid(), findFuncByOid(), findIndexByOid(), findNamespaceByOid(), findOprByOid(), findPublicationByOid(), findTableByOid(), and findTypeByOid().

 {
     DumpableObject **low;
     DumpableObject **high;
 
     /*
      * This is the same as findObjectByCatalogId except we assume we need not
      * look at table OID because the objects are all the same type.
      *
      * We could use bsearch() here, but the notational cruft of calling
      * bsearch is nearly as bad as doing it ourselves; and the generalized
      * bsearch function is noticeably slower as well.
      */
     if (numObjs <= 0)
         return NULL;
     low = indexArray;
     high = indexArray + (numObjs - 1);
     while (low <= high)
     {
         DumpableObject **middle;
         int         difference;
 
         middle = low + (high - low) / 2;
         difference = oidcmp((*middle)->catId.oid, oid);
         if (difference == 0)
             return *middle;
         else if (difference < 0)
             low = middle + 1;
         else
             high = middle - 1;
     }
     return NULL;
 }

◆ findOprByOid()

OprInfo* findOprByOid ( Oid oid )

Definition at line 926 of file common.c.

References findObjectByOid(), and numOperators.

Referenced by getFormattedOperatorName().

 {
     return (OprInfo *) findObjectByOid(oid, oprinfoindex, numOperators);
 }

◆ findOwningExtension()

ExtensionInfo* findOwningExtension ( CatalogId catalogId )

Definition at line 1009 of file common.c.

References _extensionMemberId::catId, difference(), _extensionMemberId::ext, extmembers, numextmembers, CatalogId::oid, oidcmp, and CatalogId::tableoid.

Referenced by checkExtensionMembership().

 {
     ExtensionMemberId *low;
     ExtensionMemberId *high;
 
     /*
      * We could use bsearch() here, but the notational cruft of calling
      * bsearch is nearly as bad as doing it ourselves; and the generalized
      * bsearch function is noticeably slower as well.
      */
     if (numextmembers <= 0)
         return NULL;
     low = extmembers;
     high = extmembers + (numextmembers - 1);
     while (low <= high)
     {
         ExtensionMemberId *middle;
         int         difference;
 
         middle = low + (high - low) / 2;
         /* comparison must match ExtensionMemberIdCompare, below */
         difference = oidcmp(middle->catId.oid, catalogId.oid);
         if (difference == 0)
             difference = oidcmp(middle->catId.tableoid, catalogId.tableoid);
         if (difference == 0)
             return middle->ext;
         else if (difference < 0)
             low = middle + 1;
         else
             high = middle - 1;
     }
     return NULL;
 }

◆ findParentsByOid()

static void findParentsByOid	(	TableInfo *	self,
		InhInfo *	inhinfo,
		int	numInherits
	)

static

Definition at line 1069 of file common.c.

References exit_nicely, findTableByOid(), i, _tableInfo::parents, pg_log_error, and pg_malloc().

Referenced by flagInhTables().

 {
     Oid         oid = self->dobj.catId.oid;
     int         i,
                 j;
     int         numParents;
 
     numParents = 0;
     for (i = 0; i < numInherits; i++)
     {
         if (inhinfo[i].inhrelid == oid)
             numParents++;
     }
 
     self->numParents = numParents;
 
     if (numParents > 0)
     {
         self->parents = (TableInfo **)
             pg_malloc(sizeof(TableInfo *) * numParents);
         j = 0;
         for (i = 0; i < numInherits; i++)
         {
             if (inhinfo[i].inhrelid == oid)
             {
                 TableInfo  *parent;
 
                 parent = findTableByOid(inhinfo[i].inhparent);
                 if (parent == NULL)
                 {
                     pg_log_error("failed sanity check, parent OID %u of table \"%s\" (OID %u) not found",
                                  inhinfo[i].inhparent,
                                  self->dobj.name,
                                  oid);
                     exit_nicely(1);
                 }
                 self->parents[j++] = parent;
             }
         }
     }
     else
         self->parents = NULL;
 }

◆ findPublicationByOid()

PublicationInfo* findPublicationByOid ( Oid oid )

Definition at line 970 of file common.c.

References findObjectByOid(), and numPublications.

Referenced by getPublicationTables().

 {
     return (PublicationInfo *) findObjectByOid(oid, pubinfoindex, numPublications);
 }

◆ findTableByOid()

TableInfo* findTableByOid ( Oid oid )

Definition at line 893 of file common.c.

References findObjectByOid(), and numTables.

Referenced by dumpSequence(), findParentsByOid(), getConstraints(), getOwnedSeqs(), getPolicies(), getPublicationTables(), getRules(), getTableDataFKConstraints(), processExtensionTables(), and selectDumpableType().

 {
     return (TableInfo *) findObjectByOid(oid, tblinfoindex, numTables);
 }

◆ findTypeByOid()

TypeInfo* findTypeByOid ( Oid oid )

Definition at line 904 of file common.c.

References findObjectByOid(), and numTypes.

Referenced by DOTypeNameCompare(), getCasts(), getFormattedTypeName(), and getTransforms().

 {
     return (TypeInfo *) findObjectByOid(oid, typinfoindex, numTypes);
 }

◆ flagInhAttrs()

static void flagInhAttrs	(	DumpOptions *	dopt,
		TableInfo *	tblinfo,
		int	numTables
	)

static

Definition at line 492 of file common.c.

References addObjectDependency(), _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, AssignDumpId(), _tableInfo::attgenerated, _tableInfo::attisdropped, _tableInfo::attnames, _tableInfo::attrdefs, _dumpOptions::binary_upgrade, _dumpableObject::catId, DO_ATTRDEF, _tableInfo::dobj, _attrDefInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, i, _tableInfo::inhNotNull, _tableInfo::ispartition, _dumpableObject::name, _tableInfo::notnull, _tableInfo::numatts, _tableInfo::numParents, numTables, _dumpableObject::objType, CatalogId::oid, _tableInfo::parents, pg_malloc(), pg_strdup(), _tableInfo::relkind, _attrDefInfo::separate, shouldPrintColumn(), strInArray(), and CatalogId::tableoid.

Referenced by getSchemaData().

 {
     int         i,
                 j,
                 k;
 
     for (i = 0; i < numTables; i++)
     {
         TableInfo  *tbinfo = &(tblinfo[i]);
         int         numParents;
         TableInfo **parents;
 
         /* Some kinds never have parents */
         if (tbinfo->relkind == RELKIND_SEQUENCE ||
             tbinfo->relkind == RELKIND_VIEW ||
             tbinfo->relkind == RELKIND_MATVIEW)
             continue;
 
         /* Don't bother computing anything for non-target tables, either */
         if (!tbinfo->dobj.dump)
             continue;
 
         numParents = tbinfo->numParents;
         parents = tbinfo->parents;
 
         if (numParents == 0)
             continue;           /* nothing to see here, move along */
 
         /* For each column, search for matching column names in parent(s) */
         for (j = 0; j < tbinfo->numatts; j++)
         {
             bool        foundNotNull;   /* Attr was NOT NULL in a parent */
             bool        foundDefault;   /* Found a default in a parent */
             bool        foundGenerated; /* Found a generated in a parent */
 
             /* no point in examining dropped columns */
             if (tbinfo->attisdropped[j])
                 continue;
 
             foundNotNull = false;
             foundDefault = false;
             foundGenerated = false;
             for (k = 0; k < numParents; k++)
             {
                 TableInfo  *parent = parents[k];
                 int         inhAttrInd;
 
                 inhAttrInd = strInArray(tbinfo->attnames[j],
                                         parent->attnames,
                                         parent->numatts);
                 if (inhAttrInd >= 0)
                 {
                     foundNotNull |= parent->notnull[inhAttrInd];
                     foundDefault |= (parent->attrdefs[inhAttrInd] != NULL && !parent->attgenerated[inhAttrInd]);
                     foundGenerated |= parent->attgenerated[inhAttrInd];
                 }
             }
 
             /* Remember if we found inherited NOT NULL */
             tbinfo->inhNotNull[j] = foundNotNull;
 
             /* Manufacture a DEFAULT NULL clause if necessary */
             if (foundDefault && tbinfo->attrdefs[j] == NULL)
             {
                 AttrDefInfo *attrDef;
 
                 attrDef = (AttrDefInfo *) pg_malloc(sizeof(AttrDefInfo));
                 attrDef->dobj.objType = DO_ATTRDEF;
                 attrDef->dobj.catId.tableoid = 0;
                 attrDef->dobj.catId.oid = 0;
                 AssignDumpId(&attrDef->dobj);
                 attrDef->dobj.name = pg_strdup(tbinfo->dobj.name);
                 attrDef->dobj.namespace = tbinfo->dobj.namespace;
                 attrDef->dobj.dump = tbinfo->dobj.dump;
 
                 attrDef->adtable = tbinfo;
                 attrDef->adnum = j + 1;
                 attrDef->adef_expr = pg_strdup("NULL");
 
                 /* Will column be dumped explicitly? */
                 if (shouldPrintColumn(dopt, tbinfo, j))
                 {
                     attrDef->separate = false;
                     /* No dependency needed: NULL cannot have dependencies */
                 }
                 else
                 {
                     /* column will be suppressed, print default separately */
                     attrDef->separate = true;
                     /* ensure it comes out after the table */
                     addObjectDependency(&attrDef->dobj,
                                         tbinfo->dobj.dumpId);
                 }
 
                 tbinfo->attrdefs[j] = attrDef;
             }
 
             /* Remove generation expression from child */
             if (foundGenerated && !tbinfo->ispartition && !dopt->binary_upgrade)
                 tbinfo->attrdefs[j] = NULL;
         }
     }
 }

◆ flagInhIndexes() [1/2]

static void flagInhIndexes	(	Archive *	fout,
		TableInfo *	tblinfo,
		int	numTables
	)

static

Referenced by getSchemaData().

◆ flagInhIndexes() [2/2]

static void flagInhIndexes	(	Archive *	fout,
		TableInfo	tblinfo[],
		int	numTables
	)

static

Definition at line 373 of file common.c.

References addObjectDependency(), Assert, AssignDumpId(), buildIndexArray(), _dumpableObject::catId, DO_INDEX_ATTACH, _tableInfo::dobj, _indxInfo::dobj, _indexAttachInfo::dobj, _dumpableObject::dumpId, findIndexByOid(), getMaxDumpId(), i, _tableInfo::indexes, _indxInfo::indextable, _dumpableObject::name, _tableInfo::numIndexes, numTables, _dumpableObject::objType, CatalogId::oid, _indxInfo::parentidx, _indexAttachInfo::parentIdx, _tableInfo::parents, _indxInfo::partattaches, _indexAttachInfo::partitionIdx, pg_free(), pg_malloc0(), pg_strdup(), simple_ptr_list_append(), and CatalogId::tableoid.

 {
     int         i,
                 j,
                 k;
     DumpableObject ***parentIndexArray;
 
     parentIndexArray = (DumpableObject ***)
         pg_malloc0(getMaxDumpId() * sizeof(DumpableObject **));
 
     for (i = 0; i < numTables; i++)
     {
         TableInfo  *parenttbl;
         IndexAttachInfo *attachinfo;
 
         if (!tblinfo[i].ispartition || tblinfo[i].numParents == 0)
             continue;
 
         Assert(tblinfo[i].numParents == 1);
         parenttbl = tblinfo[i].parents[0];
 
         /*
          * We need access to each parent table's index list, but there is no
          * index to cover them outside of this function.  To avoid having to
          * sort every parent table's indexes each time we come across each of
          * its partitions, create an indexed array for each parent the first
          * time it is required.
          */
         if (parentIndexArray[parenttbl->dobj.dumpId] == NULL)
             parentIndexArray[parenttbl->dobj.dumpId] =
                 buildIndexArray(parenttbl->indexes,
                                 parenttbl->numIndexes,
                                 sizeof(IndxInfo));
 
         attachinfo = (IndexAttachInfo *)
             pg_malloc0(tblinfo[i].numIndexes * sizeof(IndexAttachInfo));
         for (j = 0, k = 0; j < tblinfo[i].numIndexes; j++)
         {
             IndxInfo   *index = &(tblinfo[i].indexes[j]);
             IndxInfo   *parentidx;
 
             if (index->parentidx == 0)
                 continue;
 
             parentidx = findIndexByOid(index->parentidx,
                                        parentIndexArray[parenttbl->dobj.dumpId],
                                        parenttbl->numIndexes);
             if (parentidx == NULL)
                 continue;
 
             attachinfo[k].dobj.objType = DO_INDEX_ATTACH;
             attachinfo[k].dobj.catId.tableoid = 0;
             attachinfo[k].dobj.catId.oid = 0;
             AssignDumpId(&attachinfo[k].dobj);
             attachinfo[k].dobj.name = pg_strdup(index->dobj.name);
             attachinfo[k].dobj.namespace = index->indextable->dobj.namespace;
             attachinfo[k].parentIdx = parentidx;
             attachinfo[k].partitionIdx = index;
 
             /*
              * We must state the DO_INDEX_ATTACH object's dependencies
              * explicitly, since it will not match anything in pg_depend.
              *
              * Give it dependencies on both the partition index and the parent
              * index, so that it will not be executed till both of those
              * exist.  (There's no need to care what order those are created
              * in.)
              *
              * In addition, give it dependencies on the indexes' underlying
              * tables.  This does nothing of great value so far as serial
              * restore ordering goes, but it ensures that a parallel restore
              * will not try to run the ATTACH concurrently with other
              * operations on those tables.
              */
             addObjectDependency(&attachinfo[k].dobj, index->dobj.dumpId);
             addObjectDependency(&attachinfo[k].dobj, parentidx->dobj.dumpId);
             addObjectDependency(&attachinfo[k].dobj,
                                 index->indextable->dobj.dumpId);
             addObjectDependency(&attachinfo[k].dobj,
                                 parentidx->indextable->dobj.dumpId);
 
             /* keep track of the list of partitions in the parent index */
             simple_ptr_list_append(&parentidx->partattaches, &attachinfo[k].dobj);
 
             k++;
         }
     }
 
     for (i = 0; i < numTables; i++)
         if (parentIndexArray[i])
             pg_free(parentIndexArray[i]);
     pg_free(parentIndexArray);
 }

◆ flagInhTables()

static void flagInhTables	(	Archive *	fout,
		TableInfo *	tbinfo,
		int	numTables,
		InhInfo *	inhinfo,
		int	numInherits
	)

static

Definition at line 280 of file common.c.

References addObjectDependency(), AssignDumpId(), _dumpableObject::catId, DO_TABLE_ATTACH, _tableInfo::dobj, _tableAttachInfo::dobj, Archive::dopt, _dumpableObject::dumpId, fatal, findParentsByOid(), i, _tableInfo::ispartition, _dumpOptions::load_via_partition_root, _dumpableObject::name, _tableInfo::numParents, numTables, _dumpableObject::objType, CatalogId::oid, palloc(), _tableInfo::parents, _tableAttachInfo::parentTbl, _tableAttachInfo::partitionTbl, pg_strdup(), and CatalogId::tableoid.

Referenced by getSchemaData().

 {
     DumpOptions *dopt = fout->dopt;
     int         i,
                 j;
 
     for (i = 0; i < numTables; i++)
     {
         bool        find_parents = true;
         bool        mark_parents = true;
 
         /* Some kinds never have parents */
         if (tblinfo[i].relkind == RELKIND_SEQUENCE ||
             tblinfo[i].relkind == RELKIND_VIEW ||
             tblinfo[i].relkind == RELKIND_MATVIEW)
             continue;
 
         /*
          * Normally, we don't bother computing anything for non-target tables,
          * but if load-via-partition-root is specified, we gather information
          * on every partition in the system so that getRootTableInfo can trace
          * from any given to leaf partition all the way up to the root.  (We
          * don't need to mark them as interesting for getTableAttrs, though.)
          */
         if (!tblinfo[i].dobj.dump)
         {
             mark_parents = false;
 
             if (!dopt->load_via_partition_root ||
                 !tblinfo[i].ispartition)
                 find_parents = false;
         }
 
         /* If needed, find all the immediate parent tables. */
         if (find_parents)
             findParentsByOid(&tblinfo[i], inhinfo, numInherits);
 
         /*
          * If needed, mark the parents as interesting for getTableAttrs and
          * getIndexes.
          */
         if (mark_parents)
         {
             int         numParents = tblinfo[i].numParents;
             TableInfo **parents = tblinfo[i].parents;
 
             for (j = 0; j < numParents; j++)
                 parents[j]->interesting = true;
         }
 
         /* Create TableAttachInfo object if needed */
         if (tblinfo[i].dobj.dump && tblinfo[i].ispartition)
         {
             TableAttachInfo *attachinfo;
 
             /* With partitions there can only be one parent */
             if (tblinfo[i].numParents != 1)
                 fatal("invalid number of parents %d for table \"%s\"",
                       tblinfo[i].numParents,
                       tblinfo[i].dobj.name);
 
             attachinfo = (TableAttachInfo *) palloc(sizeof(TableAttachInfo));
             attachinfo->dobj.objType = DO_TABLE_ATTACH;
             attachinfo->dobj.catId.tableoid = 0;
             attachinfo->dobj.catId.oid = 0;
             AssignDumpId(&attachinfo->dobj);
             attachinfo->dobj.name = pg_strdup(tblinfo[i].dobj.name);
             attachinfo->dobj.namespace = tblinfo[i].dobj.namespace;
             attachinfo->parentTbl = tblinfo[i].parents[0];
             attachinfo->partitionTbl = &tblinfo[i];
 
             /*
              * We must state the DO_TABLE_ATTACH object's dependencies
              * explicitly, since it will not match anything in pg_depend.
              *
              * Give it dependencies on both the partition table and the parent
              * table, so that it will not be executed till both of those
              * exist.  (There's no need to care what order those are created
              * in.)
              */
             addObjectDependency(&attachinfo->dobj, tblinfo[i].dobj.dumpId);
             addObjectDependency(&attachinfo->dobj, tblinfo[i].parents[0]->dobj.dumpId);
         }
     }
 }

◆ getDumpableObjects()

void getDumpableObjects	(	DumpableObject ***	objs,
		int *	numObjs
	)

Definition at line 824 of file common.c.

References allocedDumpIds, i, and pg_malloc().

Referenced by findObjectByCatalogId(), getTableDataFKConstraints(), and main().

 {
     int         i,
                 j;
 
     *objs = (DumpableObject **)
         pg_malloc(allocedDumpIds * sizeof(DumpableObject *));
     j = 0;
     for (i = 1; i < allocedDumpIds; i++)
     {
         if (dumpIdMap[i])
             (*objs)[j++] = dumpIdMap[i];
     }
     *numObjs = j;
 }

◆ getMaxDumpId()

DumpId getMaxDumpId ( void )

Definition at line 660 of file common.c.

References lastDumpId.

Referenced by findDependencyLoops(), flagInhIndexes(), and TopoSort().

 {
     return lastDumpId;
 }

◆ getSchemaData()

TableInfo* getSchemaData	(	Archive *	fout,
		int *	numTablesPtr
	)

Definition at line 89 of file common.c.

References buildIndexArray(), Archive::dopt, flagInhAttrs(), flagInhIndexes(), flagInhTables(), getAccessMethods(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getOwnedSeqs(), getPolicies(), getProcLangs(), getPublications(), getPublicationTables(), getRules(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), numCollations, numExtensions, numFuncs, numNamespaces, numOperators, numPublications, numTables, numTypes, pg_log_info, and processExtensionTables().

Referenced by main().

 {
     TableInfo  *tblinfo;
     TypeInfo   *typinfo;
     FuncInfo   *funinfo;
     OprInfo    *oprinfo;
     CollInfo   *collinfo;
     NamespaceInfo *nspinfo;
     ExtensionInfo *extinfo;
     PublicationInfo *pubinfo;
     InhInfo    *inhinfo;
     int         numAggregates;
     int         numInherits;
     int         numRules;
     int         numProcLangs;
     int         numCasts;
     int         numTransforms;
     int         numAccessMethods;
     int         numOpclasses;
     int         numOpfamilies;
     int         numConversions;
     int         numTSParsers;
     int         numTSTemplates;
     int         numTSDicts;
     int         numTSConfigs;
     int         numForeignDataWrappers;
     int         numForeignServers;
     int         numDefaultACLs;
     int         numEventTriggers;
 
     /*
      * We must read extensions and extension membership info first, because
      * extension membership needs to be consultable during decisions about
      * whether other objects are to be dumped.
      */
     pg_log_info("reading extensions");
     extinfo = getExtensions(fout, &numExtensions);
     extinfoindex = buildIndexArray(extinfo, numExtensions, sizeof(ExtensionInfo));
 
     pg_log_info("identifying extension members");
     getExtensionMembership(fout, extinfo, numExtensions);
 
     pg_log_info("reading schemas");
     nspinfo = getNamespaces(fout, &numNamespaces);
     nspinfoindex = buildIndexArray(nspinfo, numNamespaces, sizeof(NamespaceInfo));
 
     /*
      * getTables should be done as soon as possible, so as to minimize the
      * window between starting our transaction and acquiring per-table locks.
      * However, we have to do getNamespaces first because the tables get
      * linked to their containing namespaces during getTables.
      */
     pg_log_info("reading user-defined tables");
     tblinfo = getTables(fout, &numTables);
     tblinfoindex = buildIndexArray(tblinfo, numTables, sizeof(TableInfo));
 
     /* Do this after we've built tblinfoindex */
     getOwnedSeqs(fout, tblinfo, numTables);
 
     pg_log_info("reading user-defined functions");
     funinfo = getFuncs(fout, &numFuncs);
     funinfoindex = buildIndexArray(funinfo, numFuncs, sizeof(FuncInfo));
 
     /* this must be after getTables and getFuncs */
     pg_log_info("reading user-defined types");
     typinfo = getTypes(fout, &numTypes);
     typinfoindex = buildIndexArray(typinfo, numTypes, sizeof(TypeInfo));
 
     /* this must be after getFuncs, too */
     pg_log_info("reading procedural languages");
     getProcLangs(fout, &numProcLangs);
 
     pg_log_info("reading user-defined aggregate functions");
     getAggregates(fout, &numAggregates);
 
     pg_log_info("reading user-defined operators");
     oprinfo = getOperators(fout, &numOperators);
     oprinfoindex = buildIndexArray(oprinfo, numOperators, sizeof(OprInfo));
 
     pg_log_info("reading user-defined access methods");
     getAccessMethods(fout, &numAccessMethods);
 
     pg_log_info("reading user-defined operator classes");
     getOpclasses(fout, &numOpclasses);
 
     pg_log_info("reading user-defined operator families");
     getOpfamilies(fout, &numOpfamilies);
 
     pg_log_info("reading user-defined text search parsers");
     getTSParsers(fout, &numTSParsers);
 
     pg_log_info("reading user-defined text search templates");
     getTSTemplates(fout, &numTSTemplates);
 
     pg_log_info("reading user-defined text search dictionaries");
     getTSDictionaries(fout, &numTSDicts);
 
     pg_log_info("reading user-defined text search configurations");
     getTSConfigurations(fout, &numTSConfigs);
 
     pg_log_info("reading user-defined foreign-data wrappers");
     getForeignDataWrappers(fout, &numForeignDataWrappers);
 
     pg_log_info("reading user-defined foreign servers");
     getForeignServers(fout, &numForeignServers);
 
     pg_log_info("reading default privileges");
     getDefaultACLs(fout, &numDefaultACLs);
 
     pg_log_info("reading user-defined collations");
     collinfo = getCollations(fout, &numCollations);
     collinfoindex = buildIndexArray(collinfo, numCollations, sizeof(CollInfo));
 
     pg_log_info("reading user-defined conversions");
     getConversions(fout, &numConversions);
 
     pg_log_info("reading type casts");
     getCasts(fout, &numCasts);
 
     pg_log_info("reading transforms");
     getTransforms(fout, &numTransforms);
 
     pg_log_info("reading table inheritance information");
     inhinfo = getInherits(fout, &numInherits);
 
     pg_log_info("reading event triggers");
     getEventTriggers(fout, &numEventTriggers);
 
     /* Identify extension configuration tables that should be dumped */
     pg_log_info("finding extension tables");
     processExtensionTables(fout, extinfo, numExtensions);
 
     /* Link tables to parents, mark parents of target tables interesting */
     pg_log_info("finding inheritance relationships");
     flagInhTables(fout, tblinfo, numTables, inhinfo, numInherits);
 
     pg_log_info("reading column info for interesting tables");
     getTableAttrs(fout, tblinfo, numTables);
 
     pg_log_info("flagging inherited columns in subtables");
     flagInhAttrs(fout->dopt, tblinfo, numTables);
 
     pg_log_info("reading indexes");
     getIndexes(fout, tblinfo, numTables);
 
     pg_log_info("flagging indexes in partitioned tables");
     flagInhIndexes(fout, tblinfo, numTables);
 
     pg_log_info("reading extended statistics");
     getExtendedStatistics(fout);
 
     pg_log_info("reading constraints");
     getConstraints(fout, tblinfo, numTables);
 
     pg_log_info("reading triggers");
     getTriggers(fout, tblinfo, numTables);
 
     pg_log_info("reading rewrite rules");
     getRules(fout, &numRules);
 
     pg_log_info("reading policies");
     getPolicies(fout, tblinfo, numTables);
 
     pg_log_info("reading publications");
     pubinfo = getPublications(fout, &numPublications);
     pubinfoindex = buildIndexArray(pubinfo, numPublications,
                                    sizeof(PublicationInfo));
 
     pg_log_info("reading publication membership");
     getPublicationTables(fout, tblinfo, numTables);
 
     pg_log_info("reading subscriptions");
     getSubscriptions(fout);
 
     *numTablesPtr = numTables;
     return tblinfo;
 }

◆ parseOidArray()

void parseOidArray	(	const char *	str,
		Oid *	array,
		int	arraysize
	)

Definition at line 1124 of file common.c.

References atooid, exit_nicely, InvalidOid, and pg_log_error.

Referenced by dumpFunc(), getAggregates(), getFuncs(), and getIndexes().

 {
     int         j,
                 argNum;
     char        temp[100];
     char        s;
 
     argNum = 0;
     j = 0;
     for (;;)
     {
         s = *str++;
         if (s == ' ' || s == '\0')
         {
             if (j > 0)
             {
                 if (argNum >= arraysize)
                 {
                     pg_log_error("could not parse numeric array \"%s\": too many numbers", str);
                     exit_nicely(1);
                 }
                 temp[j] = '\0';
                 array[argNum++] = atooid(temp);
                 j = 0;
             }
             if (s == '\0')
                 break;
         }
         else
         {
             if (!(isdigit((unsigned char) s) || s == '-') ||
                 j >= sizeof(temp) - 1)
             {
                 pg_log_error("could not parse numeric array \"%s\": invalid character in number", str);
                 exit_nicely(1);
             }
             temp[j++] = s;
         }
     }
 
     while (argNum < arraysize)
         array[argNum++] = InvalidOid;
 }

◆ removeObjectDependency()

void removeObjectDependency	(	DumpableObject *	dobj,
		DumpId	refId
	)

Definition at line 873 of file common.c.

References _dumpableObject::dependencies, i, and _dumpableObject::nDeps.

Referenced by repairDependencyLoop(), repairDomainConstraintLoop(), repairDomainConstraintMultiLoop(), repairIndexLoop(), repairMatViewBoundaryMultiLoop(), repairTableAttrDefLoop(), repairTableAttrDefMultiLoop(), repairTableConstraintLoop(), repairTableConstraintMultiLoop(), repairTypeFuncLoop(), repairViewRuleLoop(), and repairViewRuleMultiLoop().

 {
     int         i;
     int         j = 0;
 
     for (i = 0; i < dobj->nDeps; i++)
     {
         if (dobj->dependencies[i] != refId)
             dobj->dependencies[j++] = dobj->dependencies[i];
     }
     dobj->nDeps = j;
 }

◆ setExtensionMembership()

void setExtensionMembership	(	ExtensionMemberId *	extmems,
		int	nextmems
	)

Definition at line 993 of file common.c.

References ExtensionMemberIdCompare(), numextmembers, and qsort.

Referenced by getExtensionMembership().

 {
     /* Sort array in preparation for binary searches */
     if (nextmems > 1)
         qsort((void *) extmems, nextmems, sizeof(ExtensionMemberId),
               ExtensionMemberIdCompare);
     /* And save */
     extmembers = extmems;
     numextmembers = nextmems;
 }

◆ strInArray()

static int strInArray	(	const char *	pattern,
		char **	arr,
		int	arr_size
	)

static

Definition at line 1177 of file common.c.

References i.

Referenced by flagInhAttrs().

 {
     int         i;
 
     for (i = 0; i < arr_size; i++)
     {
         if (strcmp(pattern, arr[i]) == 0)
             return i;
     }
     return -1;
 }

Variable Documentation

◆ allocedDumpIds

int allocedDumpIds = 0

static

Definition at line 30 of file common.c.

Referenced by AssignDumpId(), findObjectByDumpId(), and getDumpableObjects().

◆ catalogIdMap

DumpableObject** catalogIdMap = NULL

static

Definition at line 37 of file common.c.

Referenced by findObjectByCatalogId().

◆ catalogIdMapValid

bool catalogIdMapValid = false

static

Definition at line 36 of file common.c.

Referenced by AssignDumpId(), and findObjectByCatalogId().

◆ collinfoindex

DumpableObject** collinfoindex

static

Definition at line 52 of file common.c.

◆ dumpIdMap

DumpableObject** dumpIdMap = NULL

static

Definition at line 29 of file common.c.

◆ extinfoindex

DumpableObject** extinfoindex

static

Definition at line 54 of file common.c.

◆ extmembers

ExtensionMemberId* extmembers

static

Definition at line 66 of file common.c.

Referenced by findOwningExtension(), and getExtensionMembership().

◆ funinfoindex

DumpableObject** funinfoindex

static

Definition at line 50 of file common.c.

◆ lastDumpId

DumpId lastDumpId = 0

static

Definition at line 31 of file common.c.

Referenced by AssignDumpId(), createDumpId(), and getMaxDumpId().

◆ nspinfoindex

DumpableObject** nspinfoindex

static

Definition at line 53 of file common.c.

◆ numCatalogIds

int numCatalogIds = 0

static

Definition at line 38 of file common.c.

Referenced by findObjectByCatalogId().

◆ numCollations

int numCollations

static

Definition at line 60 of file common.c.

Referenced by findCollationByOid(), and getSchemaData().

◆ numExtensions

int numExtensions

static

Definition at line 62 of file common.c.

Referenced by findExtensionByOid(), getSchemaData(), and processExtensionTables().

◆ numextmembers

int numextmembers

static

Definition at line 67 of file common.c.

Referenced by findOwningExtension(), and setExtensionMembership().

◆ numFuncs

int numFuncs

static

Definition at line 58 of file common.c.

Referenced by findFuncByOid(), and getSchemaData().

◆ numNamespaces

int numNamespaces

static

Definition at line 61 of file common.c.

Referenced by findNamespaceByOid(), and getSchemaData().

◆ numOperators

int numOperators

static

Definition at line 59 of file common.c.

Referenced by findOprByOid(), and getSchemaData().

◆ numPublications

int numPublications

static

Definition at line 63 of file common.c.

Referenced by findPublicationByOid(), and getSchemaData().

◆ numTables

int numTables

static

Definition at line 56 of file common.c.

Referenced by findTableByOid(), flagInhAttrs(), flagInhIndexes(), flagInhTables(), getConstraints(), getIndexes(), getOwnedSeqs(), getPolicies(), getSchemaData(), getTableAttrs(), getTableData(), getTriggers(), guessConstraintInheritance(), and main().

◆ numTypes

int numTypes

static

Definition at line 57 of file common.c.

Referenced by findTypeByOid(), and getSchemaData().

◆ oprinfoindex

DumpableObject** oprinfoindex

static

Definition at line 51 of file common.c.

◆ pubinfoindex

DumpableObject** pubinfoindex

static

Definition at line 55 of file common.c.

◆ tblinfoindex

DumpableObject** tblinfoindex

static

Definition at line 48 of file common.c.

◆ typinfoindex

DumpableObject** typinfoindex

static

Definition at line 49 of file common.c.

Functions

Variables

Function Documentation

◆ addObjectDependency()

◆ AssignDumpId()

◆ buildIndexArray()

◆ createDumpId()

◆ DOCatalogIdCompare()

◆ ExtensionMemberIdCompare()

◆ findCollationByOid()

◆ findExtensionByOid()

◆ findFuncByOid()

◆ findIndexByOid()

◆ findNamespaceByOid()

◆ findObjectByCatalogId()

◆ findObjectByDumpId()

◆ findObjectByOid()

◆ findOprByOid()

◆ findOwningExtension()

◆ findParentsByOid()

◆ findPublicationByOid()

◆ findTableByOid()

◆ findTypeByOid()

◆ flagInhAttrs()

◆ flagInhIndexes() [1/2]

◆ flagInhIndexes() [2/2]

◆ flagInhTables()

◆ getDumpableObjects()

◆ getMaxDumpId()

◆ getSchemaData()

◆ parseOidArray()

◆ removeObjectDependency()

◆ setExtensionMembership()

◆ strInArray()

Variable Documentation

◆ allocedDumpIds

◆ catalogIdMap

◆ catalogIdMapValid

◆ collinfoindex

◆ dumpIdMap

◆ extinfoindex

◆ extmembers

◆ funinfoindex

◆ lastDumpId

◆ nspinfoindex

◆ numCatalogIds

◆ numCollations

◆ numExtensions

◆ numextmembers

◆ numFuncs

◆ numNamespaces

◆ numOperators

◆ numPublications

◆ numTables

◆ numTypes

◆ oprinfoindex

◆ pubinfoindex

◆ tblinfoindex

◆ typinfoindex