common.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include "catalog/pg_class_d.h"
#include "catalog/pg_collation_d.h"
#include "catalog/pg_extension_d.h"
#include "catalog/pg_namespace_d.h"
#include "catalog/pg_operator_d.h"
#include "catalog/pg_proc_d.h"
#include "catalog/pg_publication_d.h"
#include "catalog/pg_type_d.h"
#include "common/hashfn.h"
#include "fe_utils/string_utils.h"
#include "pg_backup_archiver.h"
#include "pg_backup_utils.h"
#include "pg_dump.h"
#include "lib/simplehash.h"

Include dependency graph for common.c:

Go to the source code of this file.

Data Structures
struct	_catalogIdMapEntry

Macros
#define	SH_PREFIX   catalogid
#define	SH_ELEMENT_TYPE   CatalogIdMapEntry
#define	SH_KEY_TYPE   CatalogId
#define	SH_KEY   catId
#define	SH_HASH_KEY(tb, key)   hash_bytes((const unsigned char *) &(key), sizeof(CatalogId))
#define	SH_EQUAL(tb, a, b)   ((a).oid == (b).oid && (a).tableoid == (b).tableoid)
#define	SH_STORE_HASH
#define	SH_GET_HASH(tb, a)   (a)->hashval
#define	SH_SCOPE   static inline
#define	SH_RAW_ALLOCATOR   pg_malloc0
#define	SH_DECLARE
#define	SH_DEFINE
#define	CATALOGIDHASH_INITIAL_SIZE   10000

Typedefs
typedef struct _catalogIdMapEntry	CatalogIdMapEntry

Functions
static void	flagInhTables (Archive *fout, TableInfo *tblinfo, int numTables, InhInfo *inhinfo, int numInherits)
static void	flagInhIndexes (Archive *fout, TableInfo *tblinfo, int numTables)
static void	flagInhAttrs (Archive *fout, DumpOptions *dopt, TableInfo *tblinfo, int numTables)
static int	strInArray (const char *pattern, char **arr, int arr_size)
static IndxInfo *	findIndexByOid (Oid oid)
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)
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	recordExtensionMembership (CatalogId catId, ExtensionInfo *ext)
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 catalogid_hash *	catalogIdHash = NULL

Macro Definition Documentation

CATALOGIDHASH_INITIAL_SIZE

#define CATALOGIDHASH_INITIAL_SIZE   10000

Definition at line 78 of file common.c.

SH_DECLARE

#define SH_DECLARE

Definition at line 74 of file common.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 75 of file common.c.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   CatalogIdMapEntry

Definition at line 65 of file common.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		((a).oid == (b).oid && (a).tableoid == (b).tableoid)

Definition at line 69 of file common.c.

SH_GET_HASH

#define SH_GET_HASH	(		tb,
			a
	)		(a)->hashval

Definition at line 71 of file common.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		hash_bytes((const unsigned char *) &(key), sizeof(CatalogId))

Definition at line 68 of file common.c.

SH_KEY

#define SH_KEY   catId

Definition at line 67 of file common.c.

SH_KEY_TYPE

#define SH_KEY_TYPE   CatalogId

Definition at line 66 of file common.c.

SH_PREFIX

#define SH_PREFIX   catalogid

Definition at line 64 of file common.c.

SH_RAW_ALLOCATOR

#define SH_RAW_ALLOCATOR   pg_malloc0

Definition at line 73 of file common.c.

SH_SCOPE

#define SH_SCOPE   static inline

Definition at line 72 of file common.c.

SH_STORE_HASH

#define SH_STORE_HASH

Definition at line 70 of file common.c.

Typedef Documentation

CatalogIdMapEntry

typedef struct _catalogIdMapEntry CatalogIdMapEntry

Function Documentation

addObjectDependency()

void addObjectDependency	(	DumpableObject *	dobj,
		DumpId	refId
	)

Definition at line 779 of file common.c.

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

References _dumpableObject::allocDeps, _dumpableObject::dependencies, _dumpableObject::nDeps, pg_malloc_array, and pg_realloc_array.

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

AssignDumpId()

void AssignDumpId

(

DumpableObject *

dobj

)

Definition at line 642 of file common.c.

{
    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 */
    /* All objects have definitions; we may set more components bits later */
    dobj->components = DUMP_COMPONENT_DEFINITION;
    dobj->ext_member = false;   /* default assumption */
    dobj->depends_on_ext = false;   /* default assumption */
    dobj->dependencies = NULL;
    dobj->nDeps = 0;
    dobj->allocDeps = 0;
 
    /* Add object to dumpIdMap[], enlarging that array if need be */
    while (dobj->dumpId >= allocedDumpIds)
    {
        int         newAlloc;
 
        if (allocedDumpIds <= 0)
        {
            newAlloc = 256;
            dumpIdMap = pg_malloc_array(DumpableObject *, newAlloc);
        }
        else
        {
            newAlloc = allocedDumpIds * 2;
            dumpIdMap = pg_realloc_array(dumpIdMap, DumpableObject *, newAlloc);
        }
        memset(dumpIdMap + allocedDumpIds, 0,
               (newAlloc - allocedDumpIds) * sizeof(DumpableObject *));
        allocedDumpIds = newAlloc;
    }
    dumpIdMap[dobj->dumpId] = dobj;
 
    /* If it has a valid CatalogId, enter it into the hash table */
    if (OidIsValid(dobj->catId.tableoid))
    {
        CatalogIdMapEntry *entry;
        bool        found;
 
        /* Initialize CatalogId hash table if not done yet */
        if (catalogIdHash == NULL)
            catalogIdHash = catalogid_create(CATALOGIDHASH_INITIAL_SIZE, NULL);
 
        entry = catalogid_insert(catalogIdHash, dobj->catId, &found);
        if (!found)
        {
            entry->dobj = NULL;
            entry->ext = NULL;
        }
        Assert(entry->dobj == NULL);
        entry->dobj = dobj;
    }
}

References _dumpableObject::allocDeps, allocedDumpIds, Assert(), catalogIdHash, CATALOGIDHASH_INITIAL_SIZE, _dumpableObject::catId, _dumpableObject::components, _dumpableObject::dependencies, _dumpableObject::depends_on_ext, _catalogIdMapEntry::dobj, _dumpableObject::dump, DUMP_COMPONENT_ALL, DUMP_COMPONENT_DEFINITION, _dumpableObject::dump_contains, _dumpableObject::dumpId, dumpIdMap, _catalogIdMapEntry::ext, _dumpableObject::ext_member, lastDumpId, _dumpableObject::name, _dumpableObject::nDeps, OidIsValid, pg_malloc_array, pg_realloc_array, and CatalogId::tableoid.

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

createDumpId()

DumpId createDumpId

(

void

)

Definition at line 706 of file common.c.

{
    return ++lastDumpId;
}

References lastDumpId.

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

findCollationByOid()

CollInfo* findCollationByOid

(

Oid

oid

)

Definition at line 915 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = CollationRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_COLLATION);
    return (CollInfo *) dobj;
}

References Assert(), DO_COLLATION, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

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

findExtensionByOid()

ExtensionInfo* findExtensionByOid

(

Oid

oid

)

Definition at line 951 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = ExtensionRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_EXTENSION);
    return (ExtensionInfo *) dobj;
}

References Assert(), DO_EXTENSION, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

Referenced by getExtensionMembership().

findFuncByOid()

FuncInfo* findFuncByOid

(

Oid

oid

)

Definition at line 879 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = ProcedureRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_FUNC);
    return (FuncInfo *) dobj;
}

References Assert(), DO_FUNC, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

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

findIndexByOid()

static IndxInfo * findIndexByOid ( Oid  oid )

static

Definition at line 842 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = RelationRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_INDEX);
    return (IndxInfo *) dobj;
}

References Assert(), DO_INDEX, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

Referenced by flagInhIndexes().

findNamespaceByOid()

NamespaceInfo* findNamespaceByOid

(

Oid

oid

)

Definition at line 933 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = NamespaceRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_NAMESPACE);
    return (NamespaceInfo *) dobj;
}

References Assert(), DO_NAMESPACE, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

Referenced by findNamespace(), and getPublicationNamespaces().

findObjectByCatalogId()

DumpableObject* findObjectByCatalogId

(

CatalogId

catalogId

)

Definition at line 739 of file common.c.

{
    CatalogIdMapEntry *entry;
 
    if (catalogIdHash == NULL)
        return NULL;            /* no objects exist yet */
 
    entry = catalogid_lookup(catalogIdHash, catalogId);
    if (entry == NULL)
        return NULL;
    return entry->dobj;
}

References catalogIdHash, and _catalogIdMapEntry::dobj.

Referenced by buildMatViewRefreshDependencies(), collectComments(), collectSecLabels(), findCollationByOid(), findExtensionByOid(), findFuncByOid(), findIndexByOid(), findNamespaceByOid(), findOprByOid(), findPublicationByOid(), findTableByOid(), findTypeByOid(), getAdditionalACLs(), and getDependencies().

findObjectByDumpId()

DumpableObject* findObjectByDumpId

(

DumpId

dumpId

)

Definition at line 726 of file common.c.

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

References allocedDumpIds, and dumpIdMap.

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

findOprByOid()

OprInfo* findOprByOid

(

Oid

oid

)

Definition at line 897 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = OperatorRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_OPERATOR);
    return (OprInfo *) dobj;
}

References Assert(), DO_OPERATOR, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

Referenced by getFormattedOperatorName().

findOwningExtension()

ExtensionInfo* findOwningExtension

(

CatalogId

catalogId

)

Definition at line 1012 of file common.c.

{
    CatalogIdMapEntry *entry;
 
    if (catalogIdHash == NULL)
        return NULL;            /* no objects exist yet */
 
    entry = catalogid_lookup(catalogIdHash, catalogId);
    if (entry == NULL)
        return NULL;
    return entry->ext;
}

References catalogIdHash, and _catalogIdMapEntry::ext.

Referenced by checkExtensionMembership().

findPublicationByOid()

PublicationInfo* findPublicationByOid

(

Oid

oid

)

Definition at line 969 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = PublicationRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_PUBLICATION);
    return (PublicationInfo *) dobj;
}

References Assert(), DO_PUBLICATION, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

Referenced by getPublicationNamespaces(), and getPublicationTables().

findTableByOid()

TableInfo* findTableByOid

(

Oid

oid

)

Definition at line 824 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = RelationRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL || dobj->objType == DO_TABLE);
    return (TableInfo *) dobj;
}

References Assert(), DO_TABLE, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

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

findTypeByOid()

TypeInfo* findTypeByOid

(

Oid

oid

)

Definition at line 860 of file common.c.

{
    CatalogId   catId;
    DumpableObject *dobj;
 
    catId.tableoid = TypeRelationId;
    catId.oid = oid;
    dobj = findObjectByCatalogId(catId);
    Assert(dobj == NULL ||
           dobj->objType == DO_TYPE || dobj->objType == DO_DUMMY_TYPE);
    return (TypeInfo *) dobj;
}

References Assert(), DO_DUMMY_TYPE, DO_TYPE, findObjectByCatalogId(), _dumpableObject::objType, CatalogId::oid, and CatalogId::tableoid.

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

flagInhAttrs()

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

static

Definition at line 496 of file common.c.

{
    int         i,
                j,
                k;
 
    /*
     * We scan the tables in OID order, since that's how tblinfo[] is sorted.
     * Hence we will typically visit parents before their children --- but
     * that is *not* guaranteed.  Thus this loop must be careful that it does
     * not alter table properties in a way that could change decisions made at
     * child tables during other iterations.
     */
    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        foundSameGenerated; /* Found matching GENERATED */
            bool        foundDiffGenerated; /* Found non-matching GENERATED */
 
            /* no point in examining dropped columns */
            if (tbinfo->attisdropped[j])
                continue;
 
            foundNotNull = false;
            foundDefault = false;
            foundSameGenerated = false;
            foundDiffGenerated = 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)
                {
                    AttrDefInfo *parentDef = parent->attrdefs[inhAttrInd];
 
                    foundNotNull |= (parent->notnull_constrs[inhAttrInd] != NULL &&
                                     !parent->notnull_noinh[inhAttrInd]);
                    foundDefault |= (parentDef != NULL &&
                                     strcmp(parentDef->adef_expr, "NULL") != 0 &&
                                     !parent->attgenerated[inhAttrInd]);
                    if (parent->attgenerated[inhAttrInd])
                    {
                        /* these pointer nullness checks are just paranoia */
                        if (parentDef != NULL &&
                            tbinfo->attrdefs[j] != NULL &&
                            strcmp(parentDef->adef_expr,
                                   tbinfo->attrdefs[j]->adef_expr) == 0)
                            foundSameGenerated = true;
                        else
                            foundDiffGenerated = true;
                    }
                }
            }
 
            /* In versions < 17, remember if we found inherited NOT NULL */
            if (fout->remoteVersion < 170000)
                tbinfo->notnull_inh[j] = foundNotNull;
 
            /*
             * Manufacture a DEFAULT NULL clause if necessary.  This breaks
             * the advice given above to avoid changing state that might get
             * inspected in other loop iterations.  We prevent trouble by
             * having the foundDefault test above check whether adef_expr is
             * "NULL", so that it will reach the same conclusion before or
             * after this is done.
             */
            if (foundDefault && tbinfo->attrdefs[j] == NULL)
            {
                AttrDefInfo *attrDef;
 
                attrDef = pg_malloc_object(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;
            }
 
            /* No need to dump generation expression if it's inheritable */
            if (foundSameGenerated && !foundDiffGenerated &&
                !tbinfo->ispartition && !dopt->binary_upgrade)
                tbinfo->attrdefs[j]->dobj.dump = DUMP_COMPONENT_NONE;
        }
    }
}

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, DUMP_COMPONENT_NONE, _dumpableObject::dumpId, i, _tableInfo::ispartition, j, _dumpableObject::name, _tableInfo::notnull_constrs, _tableInfo::notnull_inh, _tableInfo::notnull_noinh, _tableInfo::numatts, _tableInfo::numParents, _dumpableObject::objType, CatalogId::oid, _tableInfo::parents, pg_malloc_object, pg_strdup(), _tableInfo::relkind, Archive::remoteVersion, _attrDefInfo::separate, shouldPrintColumn(), strInArray(), and CatalogId::tableoid.

Referenced by getSchemaData().

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 405 of file common.c.

{
    int         i,
                j;
 
    for (i = 0; i < numTables; i++)
    {
        if (!tblinfo[i].ispartition || tblinfo[i].numParents == 0)
            continue;
 
        Assert(tblinfo[i].numParents == 1);
 
        for (j = 0; j < tblinfo[i].numIndexes; j++)
        {
            IndxInfo   *index = &(tblinfo[i].indexes[j]);
            IndxInfo   *parentidx;
            IndexAttachInfo *attachinfo;
 
            if (index->parentidx == 0)
                continue;
 
            parentidx = findIndexByOid(index->parentidx);
            if (parentidx == NULL)
                continue;
 
            attachinfo = pg_malloc_object(IndexAttachInfo);
 
            attachinfo->dobj.objType = DO_INDEX_ATTACH;
            attachinfo->dobj.catId.tableoid = 0;
            attachinfo->dobj.catId.oid = 0;
            AssignDumpId(&attachinfo->dobj);
            attachinfo->dobj.name = pg_strdup(index->dobj.name);
            attachinfo->dobj.namespace = index->indextable->dobj.namespace;
            attachinfo->parentIdx = parentidx;
            attachinfo->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->dobj, index->dobj.dumpId);
            addObjectDependency(&attachinfo->dobj, parentidx->dobj.dumpId);
            addObjectDependency(&attachinfo->dobj,
                                index->indextable->dobj.dumpId);
            addObjectDependency(&attachinfo->dobj,
                                parentidx->indextable->dobj.dumpId);
 
            /* keep track of the list of partitions in the parent index */
            simple_ptr_list_append(&parentidx->partattaches, &attachinfo->dobj);
        }
    }
}

References addObjectDependency(), Assert(), AssignDumpId(), _dumpableObject::catId, DO_INDEX_ATTACH, _tableInfo::dobj, _indxInfo::dobj, _indexAttachInfo::dobj, _dumpableObject::dumpId, findIndexByOid(), i, _tableInfo::indexes, _indxInfo::indextable, j, _dumpableObject::name, _tableInfo::numIndexes, _dumpableObject::objType, CatalogId::oid, _indexAttachInfo::parentIdx, _indxInfo::partattaches, _indexAttachInfo::partitionIdx, pg_malloc_object, pg_strdup(), simple_ptr_list_append(), and CatalogId::tableoid.

flagInhTables()

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

static

Definition at line 287 of file common.c.

{
    TableInfo  *child = NULL;
    TableInfo  *parent = NULL;
    int         i,
                j;
 
    /*
     * Set up links from child tables to their parents.
     *
     * We used to attempt to skip this work for tables that are not to be
     * dumped; but the optimizable cases are rare in practice, and setting up
     * these links in bulk is cheaper than the old way.  (Note in particular
     * that it's very rare for a child to have more than one parent.)
     */
    for (i = 0; i < numInherits; i++)
    {
        /*
         * Skip a hashtable lookup if it's same table as last time.  This is
         * unlikely for the child, but less so for the parent.  (Maybe we
         * should ask the backend for a sorted array to make it more likely?
         * Not clear the sorting effort would be repaid, though.)
         */
        if (child == NULL ||
            child->dobj.catId.oid != inhinfo[i].inhrelid)
        {
            child = findTableByOid(inhinfo[i].inhrelid);
 
            /*
             * If we find no TableInfo, assume the pg_inherits entry is for a
             * partitioned index, which we don't need to track.
             */
            if (child == NULL)
                continue;
        }
        if (parent == NULL ||
            parent->dobj.catId.oid != inhinfo[i].inhparent)
        {
            parent = findTableByOid(inhinfo[i].inhparent);
            if (parent == NULL)
                pg_fatal("failed sanity check, parent OID %u of table \"%s\" (OID %u) not found",
                         inhinfo[i].inhparent,
                         child->dobj.name,
                         child->dobj.catId.oid);
        }
        /* Add this parent to the child's list of parents. */
        if (child->numParents > 0)
            child->parents = pg_realloc_array(child->parents,
                                              TableInfo *,
                                              child->numParents + 1);
        else
            child->parents = pg_malloc_array(TableInfo *, 1);
        child->parents[child->numParents++] = parent;
    }
 
    /*
     * Now consider all child tables and mark parents interesting as needed.
     */
    for (i = 0; i < numTables; i++)
    {
        /*
         * If needed, mark the parents as interesting for getTableAttrs and
         * getIndexes.  We only need this for direct parents of dumpable
         * tables.
         */
        if (tblinfo[i].dobj.dump)
        {
            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 & DUMP_COMPONENT_DEFINITION) &&
            tblinfo[i].ispartition)
        {
            TableAttachInfo *attachinfo;
 
            /* With partitions there can only be one parent */
            if (tblinfo[i].numParents != 1)
                pg_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);
        }
    }
}

References addObjectDependency(), AssignDumpId(), _dumpableObject::catId, DO_TABLE_ATTACH, _tableInfo::dobj, _tableAttachInfo::dobj, DUMP_COMPONENT_DEFINITION, _dumpableObject::dumpId, findTableByOid(), i, _inhInfo::inhparent, _inhInfo::inhrelid, _tableInfo::ispartition, j, _dumpableObject::name, _tableInfo::numParents, _dumpableObject::objType, CatalogId::oid, palloc(), _tableInfo::parents, _tableAttachInfo::parentTbl, _tableAttachInfo::partitionTbl, pg_fatal, pg_malloc_array, pg_realloc_array, pg_strdup(), and CatalogId::tableoid.

Referenced by getSchemaData().

getDumpableObjects()

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

Definition at line 758 of file common.c.

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

References allocedDumpIds, dumpIdMap, i, j, and pg_malloc_array.

Referenced by getTableDataFKConstraints(), and main().

getMaxDumpId()

DumpId getMaxDumpId

(

void

)

Definition at line 715 of file common.c.

{
    return lastDumpId;
}

References lastDumpId.

Referenced by findDependencyLoops(), and TopoSort().

getSchemaData()

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

Definition at line 96 of file common.c.

{
    TableInfo  *tblinfo;
    ExtensionInfo *extinfo;
    InhInfo    *inhinfo;
    int         numTables;
    int         numTypes;
    int         numFuncs;
    int         numOperators;
    int         numCollations;
    int         numNamespaces;
    int         numExtensions;
    int         numPublications;
    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);
 
    pg_log_info("identifying extension members");
    getExtensionMembership(fout, extinfo, numExtensions);
 
    pg_log_info("reading schemas");
    (void) getNamespaces(fout, &numNamespaces);
 
    /*
     * 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);
 
    getOwnedSeqs(fout, tblinfo, numTables);
 
    pg_log_info("reading user-defined functions");
    (void) getFuncs(fout, &numFuncs);
 
    /* this must be after getTables and getFuncs */
    pg_log_info("reading user-defined types");
    (void) getTypes(fout, &numTypes);
 
    /* 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");
    (void) getOperators(fout, &numOperators);
 
    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");
    (void) getCollations(fout, &numCollations);
 
    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, fout->dopt, tblinfo, numTables);
 
    pg_log_info("reading partitioning data");
    getPartitioningInfo(fout);
 
    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");
    (void) getPublications(fout, &numPublications);
 
    pg_log_info("reading publication membership of tables");
    getPublicationTables(fout, tblinfo, numTables);
 
    pg_log_info("reading publication membership of schemas");
    getPublicationNamespaces(fout);
 
    pg_log_info("reading subscriptions");
    getSubscriptions(fout);
 
    free(inhinfo);              /* not needed any longer */
 
    *numTablesPtr = numTables;
    return tblinfo;
}

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

Referenced by main().

parseOidArray()

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

Definition at line 1036 of file common.c.

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

References atooid, InvalidOid, j, pg_fatal, and generate_unaccent_rules::str.

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

recordExtensionMembership()

void recordExtensionMembership	(	CatalogId	catId,
		ExtensionInfo *	ext
	)

Definition at line 988 of file common.c.

{
    CatalogIdMapEntry *entry;
    bool        found;
 
    /* CatalogId hash table must exist, if we have an ExtensionInfo */
    Assert(catalogIdHash != NULL);
 
    /* Add reference to CatalogId hash */
    entry = catalogid_insert(catalogIdHash, catId, &found);
    if (!found)
    {
        entry->dobj = NULL;
        entry->ext = NULL;
    }
    Assert(entry->ext == NULL);
    entry->ext = ext;
}

References Assert(), catalogIdHash, _catalogIdMapEntry::dobj, and _catalogIdMapEntry::ext.

Referenced by getExtensionMembership().

removeObjectDependency()

void removeObjectDependency	(	DumpableObject *	dobj,
		DumpId	refId
	)

Definition at line 804 of file common.c.

{
    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;
}

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

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

strInArray()

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

static

Definition at line 1083 of file common.c.

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

References i.

Referenced by flagInhAttrs().

Variable Documentation

allocedDumpIds

int allocedDumpIds = 0

static

Definition at line 38 of file common.c.

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

catalogIdHash

catalogid_hash* catalogIdHash = NULL

static

Definition at line 80 of file common.c.

Referenced by AssignDumpId(), findObjectByCatalogId(), findOwningExtension(), and recordExtensionMembership().

dumpIdMap

DumpableObject** dumpIdMap = NULL

static

Definition at line 37 of file common.c.

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

lastDumpId

DumpId lastDumpId = 0

static

Definition at line 39 of file common.c.

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