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

Include dependency graph for common.c:

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

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)

TableInfo *	getSchemaData (Archive fout, int numTablesPtr)

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)

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 int	numTables

static int	numTypes

static int	numFuncs

static int	numOperators

static int	numCollations

static int	numNamespaces

static int	numExtensions

static ExtensionMemberId *	extmembers

static int	numextmembers

Function Documentation

void addObjectDependency	(	DumpableObject *	dobj,
		DumpId	refId
	)

Definition at line 712 of file common.c.

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

Referenced by addBoundaryDependencies(), buildMatViewRefreshDependencies(), checkExtensionMembership(), flagInhAttrs(), 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;
 }

void AssignDumpId ( DumpableObject * dobj )

Definition at line 476 of file common.c.

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

Referenced by createBoundaryObjects(), flagInhAttrs(), 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->ext_member = 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;
 }

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

static

Definition at line 647 of file common.c.

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

Referenced by getSchemaData().

 {
     DumpableObject **ptrs;
     int         i;
 
     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;
 }

DumpId createDumpId ( void )

Definition at line 520 of file common.c.

References lastDumpId.

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

 {
     return ++lastDumpId;
 }

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

static

Definition at line 668 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;
 }

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

static

Definition at line 890 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;
 }

CollInfo* findCollationByOid ( Oid oid )

Definition at line 803 of file common.c.

References findObjectByOid(), and numCollations.

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

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

ExtensionInfo* findExtensionByOid ( Oid oid )

Definition at line 825 of file common.c.

References findObjectByOid(), and numExtensions.

Referenced by getExtensionMembership().

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

FuncInfo* findFuncByOid ( Oid oid )

Definition at line 781 of file common.c.

References findObjectByOid(), and numFuncs.

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

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

NamespaceInfo* findNamespaceByOid ( Oid oid )

Definition at line 814 of file common.c.

References findObjectByOid(), and numNamespaces.

Referenced by findNamespace().

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

DumpableObject* findObjectByCatalogId ( CatalogId catalogId )

Definition at line 558 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;
 }

DumpableObject* findObjectByDumpId ( DumpId dumpId )

Definition at line 540 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];
 }

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

static

Definition at line 609 of file common.c.

References difference(), and oidcmp.

Referenced by findCollationByOid(), findExtensionByOid(), findFuncByOid(), findNamespaceByOid(), findOprByOid(), 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;
 }

OprInfo* findOprByOid ( Oid oid )

Definition at line 792 of file common.c.

References findObjectByOid(), and numOperators.

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

ExtensionInfo* findOwningExtension ( CatalogId catalogId )

Definition at line 852 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;
 }

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

static

Definition at line 912 of file common.c.

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

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)
                 {
                     write_msg(NULL, "failed sanity check, parent OID %u of table \"%s\" (OID %u) not found\n",
                               inhinfo[i].inhparent,
                               self->dobj.name,
                               oid);
                     exit_nicely(1);
                 }
                 self->parents[j++] = parent;
             }
         }
     }
     else
         self->parents = NULL;
 }

TableInfo* findTableByOid ( Oid oid )

Definition at line 759 of file common.c.

References findObjectByOid(), and numTables.

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

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

TypeInfo* findTypeByOid ( Oid oid )

Definition at line 770 of file common.c.

References findObjectByOid(), and numTypes.

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

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

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

static

Definition at line 370 of file common.c.

References addObjectDependency(), _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, AssignDumpId(), _tableInfo::attisdropped, _tableInfo::attnames, _tableInfo::attrdefs, _dumpableObject::catId, DO_ATTRDEF, _tableInfo::dobj, _attrDefInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, i, _tableInfo::inhNotNull, _dumpableObject::name, _tableInfo::notnull, _tableInfo::numatts, _tableInfo::numParents, numTables, _dumpableObject::objType, CatalogId::oid, _tableInfo::parents, pg_malloc(), pg_strdup(), _tableInfo::relkind, RELKIND_MATVIEW, RELKIND_SEQUENCE, RELKIND_VIEW, _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 */
 
             /* no point in examining dropped columns */
             if (tbinfo->attisdropped[j])
                 continue;
 
             foundNotNull = false;
             foundDefault = 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);
                 }
             }
 
             /* 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;
             }
         }
     }
 }

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

static

Definition at line 307 of file common.c.

References Archive::dopt, findParentsByOid(), i, _tableInfo::ispartition, _dumpOptions::load_via_partition_root, _tableInfo::numParents, numTables, _tableInfo::parents, RELKIND_MATVIEW, RELKIND_SEQUENCE, and RELKIND_VIEW.

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. */
         if (mark_parents)
         {
             int         numParents = tblinfo[i].numParents;
             TableInfo **parents = tblinfo[i].parents;
 
             for (j = 0; j < numParents; j++)
                 parents[j]->interesting = true;
         }
     }
 }

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

Definition at line 690 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;
 }

DumpId getMaxDumpId ( void )

Definition at line 529 of file common.c.

References lastDumpId.

Referenced by findDependencyLoops(), and TopoSort().

 {
     return lastDumpId;
 }

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

Definition at line 86 of file common.c.

References buildIndexArray(), Archive::dopt, flagInhAttrs(), flagInhTables(), g_verbose, 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, numTables, numTypes, processExtensionTables(), and write_msg().

Referenced by main().

 {
     TableInfo  *tblinfo;
     TypeInfo   *typinfo;
     FuncInfo   *funinfo;
     OprInfo    *oprinfo;
     CollInfo   *collinfo;
     NamespaceInfo *nspinfo;
     ExtensionInfo *extinfo;
     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.
      */
     if (g_verbose)
         write_msg(NULL, "reading extensions\n");
     extinfo = getExtensions(fout, &numExtensions);
     extinfoindex = buildIndexArray(extinfo, numExtensions, sizeof(ExtensionInfo));
 
     if (g_verbose)
         write_msg(NULL, "identifying extension members\n");
     getExtensionMembership(fout, extinfo, numExtensions);
 
     if (g_verbose)
         write_msg(NULL, "reading schemas\n");
     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.
      */
     if (g_verbose)
         write_msg(NULL, "reading user-defined tables\n");
     tblinfo = getTables(fout, &numTables);
     tblinfoindex = buildIndexArray(tblinfo, numTables, sizeof(TableInfo));
 
     /* Do this after we've built tblinfoindex */
     getOwnedSeqs(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined functions\n");
     funinfo = getFuncs(fout, &numFuncs);
     funinfoindex = buildIndexArray(funinfo, numFuncs, sizeof(FuncInfo));
 
     /* this must be after getTables and getFuncs */
     if (g_verbose)
         write_msg(NULL, "reading user-defined types\n");
     typinfo = getTypes(fout, &numTypes);
     typinfoindex = buildIndexArray(typinfo, numTypes, sizeof(TypeInfo));
 
     /* this must be after getFuncs, too */
     if (g_verbose)
         write_msg(NULL, "reading procedural languages\n");
     getProcLangs(fout, &numProcLangs);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined aggregate functions\n");
     getAggregates(fout, &numAggregates);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined operators\n");
     oprinfo = getOperators(fout, &numOperators);
     oprinfoindex = buildIndexArray(oprinfo, numOperators, sizeof(OprInfo));
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined access methods\n");
     getAccessMethods(fout, &numAccessMethods);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined operator classes\n");
     getOpclasses(fout, &numOpclasses);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined operator families\n");
     getOpfamilies(fout, &numOpfamilies);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined text search parsers\n");
     getTSParsers(fout, &numTSParsers);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined text search templates\n");
     getTSTemplates(fout, &numTSTemplates);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined text search dictionaries\n");
     getTSDictionaries(fout, &numTSDicts);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined text search configurations\n");
     getTSConfigurations(fout, &numTSConfigs);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined foreign-data wrappers\n");
     getForeignDataWrappers(fout, &numForeignDataWrappers);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined foreign servers\n");
     getForeignServers(fout, &numForeignServers);
 
     if (g_verbose)
         write_msg(NULL, "reading default privileges\n");
     getDefaultACLs(fout, &numDefaultACLs);
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined collations\n");
     collinfo = getCollations(fout, &numCollations);
     collinfoindex = buildIndexArray(collinfo, numCollations, sizeof(CollInfo));
 
     if (g_verbose)
         write_msg(NULL, "reading user-defined conversions\n");
     getConversions(fout, &numConversions);
 
     if (g_verbose)
         write_msg(NULL, "reading type casts\n");
     getCasts(fout, &numCasts);
 
     if (g_verbose)
         write_msg(NULL, "reading transforms\n");
     getTransforms(fout, &numTransforms);
 
     if (g_verbose)
         write_msg(NULL, "reading table inheritance information\n");
     inhinfo = getInherits(fout, &numInherits);
 
     if (g_verbose)
         write_msg(NULL, "reading event triggers\n");
     getEventTriggers(fout, &numEventTriggers);
 
     /* Identify extension configuration tables that should be dumped */
     if (g_verbose)
         write_msg(NULL, "finding extension tables\n");
     processExtensionTables(fout, extinfo, numExtensions);
 
     /* Link tables to parents, mark parents of target tables interesting */
     if (g_verbose)
         write_msg(NULL, "finding inheritance relationships\n");
     flagInhTables(fout, tblinfo, numTables, inhinfo, numInherits);
 
     if (g_verbose)
         write_msg(NULL, "reading column info for interesting tables\n");
     getTableAttrs(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "flagging inherited columns in subtables\n");
     flagInhAttrs(fout->dopt, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading indexes\n");
     getIndexes(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading extended statistics\n");
     getExtendedStatistics(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading constraints\n");
     getConstraints(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading triggers\n");
     getTriggers(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading rewrite rules\n");
     getRules(fout, &numRules);
 
     if (g_verbose)
         write_msg(NULL, "reading policies\n");
     getPolicies(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading publications\n");
     getPublications(fout);
 
     if (g_verbose)
         write_msg(NULL, "reading publication membership\n");
     getPublicationTables(fout, tblinfo, numTables);
 
     if (g_verbose)
         write_msg(NULL, "reading subscriptions\n");
     getSubscriptions(fout);
 
     *numTablesPtr = numTables;
     return tblinfo;
 }

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

Definition at line 967 of file common.c.

References atooid, exit_nicely, InvalidOid, and write_msg().

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)
                 {
                     write_msg(NULL, "could not parse numeric array \"%s\": too many numbers\n", 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)
             {
                 write_msg(NULL, "could not parse numeric array \"%s\": invalid character in number\n", str);
                 exit_nicely(1);
             }
             temp[j++] = s;
         }
     }
 
     while (argNum < arraysize)
         array[argNum++] = InvalidOid;
 }

void removeObjectDependency	(	DumpableObject *	dobj,
		DumpId	refId
	)

Definition at line 739 of file common.c.

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

Referenced by repairDependencyLoop(), repairDomainConstraintLoop(), repairDomainConstraintMultiLoop(), 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;
 }

void setExtensionMembership	(	ExtensionMemberId *	extmems,
		int	nextmems
	)

Definition at line 836 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;
 }

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

static

Definition at line 1020 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;
 }