/*-------------------------------------------------------------------------
*
* common.c
- * common routines between pg_dump and pg4_dump
+ * Catalog routines used by pg_dump; long ago these were shared
+ * by another dump tool, but not anymore.
*
- * Since pg4_dump is long-dead code, there is no longer any useful distinction
- * between this file and pg_dump.c.
- *
- * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.71 2002/10/09 16:20:25 momjian Exp $
+ * src/bin/pg_dump/common.c
*
*-------------------------------------------------------------------------
*/
-
-#include "postgres_fe.h"
-#include "pg_dump.h"
#include "pg_backup_archiver.h"
-#include "postgres.h"
-#include "catalog/pg_class.h"
#include <ctype.h>
-#include "libpq-fe.h"
-#ifndef HAVE_STRDUP
-#include "strdup.h"
-#endif
+#include "catalog/pg_class.h"
+
+
+/*
+ * Variables for mapping DumpId to DumpableObject
+ */
+static DumpableObject **dumpIdMap = NULL;
+static int allocedDumpIds = 0;
+static DumpId lastDumpId = 0;
+
+/*
+ * Variables for mapping CatalogId to DumpableObject
+ */
+static bool catalogIdMapValid = false;
+static DumpableObject **catalogIdMap = NULL;
+static int numCatalogIds = 0;
+
+/*
+ * These variables are static to avoid the notational cruft of having to pass
+ * them into findTableByOid() and friends. For each of these arrays, we
+ * build a sorted-by-OID index array immediately after it's built, and then
+ * we use binary search in findTableByOid() and friends. (qsort'ing the base
+ * arrays themselves would be simpler, but it doesn't work because pg_dump.c
+ * may have already established pointers between items.)
+ */
+static TableInfo *tblinfo;
+static TypeInfo *typinfo;
+static FuncInfo *funinfo;
+static OprInfo *oprinfo;
+static NamespaceInfo *nspinfo;
+static int numTables;
+static int numTypes;
+static int numFuncs;
+static int numOperators;
+static int numCollations;
+static int numNamespaces;
+static DumpableObject **tblinfoindex;
+static DumpableObject **typinfoindex;
+static DumpableObject **funinfoindex;
+static DumpableObject **oprinfoindex;
+static DumpableObject **collinfoindex;
+static DumpableObject **nspinfoindex;
+
-static void findParentsByOid(TableInfo *tblinfo, int numTables,
- InhInfo *inhinfo, int numInherits,
- const char *oid,
- int *numParentsPtr, int **parentIndexes);
static void flagInhTables(TableInfo *tbinfo, int numTables,
InhInfo *inhinfo, int numInherits);
-static void flagInhAttrs(TableInfo *tbinfo, int numTables,
- InhInfo *inhinfo, int numInherits);
+static void flagInhAttrs(TableInfo *tblinfo, int numTables);
+static DumpableObject **buildIndexArray(void *objArray, int numObjs,
+ Size objSize);
+static int DOCatalogIdCompare(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);
/*
- * dumpSchema:
- * we have a valid connection, we are now going to dump the schema
- * into the file
+ * getSchemaData
+ * Collect information about all potentially dumpable objects
*/
-
TableInfo *
-dumpSchema(Archive *fout,
- int *numTablesPtr,
- const bool aclsSkip,
- const bool schemaOnly,
- const bool dataOnly)
+getSchemaData(Archive *fout, int *numTablesPtr)
{
- int numNamespaces;
- int numTypes;
- int numFuncs;
- int numTables;
- int numInherits;
+ ExtensionInfo *extinfo;
+ InhInfo *inhinfo;
+ CollInfo *collinfo;
+ int numExtensions;
int numAggregates;
- int numOperators;
+ int numInherits;
+ int numRules;
+ int numProcLangs;
+ int numCasts;
int numOpclasses;
- NamespaceInfo *nsinfo;
- TypeInfo *tinfo;
- FuncInfo *finfo;
- AggInfo *agginfo;
- TableInfo *tblinfo;
- InhInfo *inhinfo;
- OprInfo *oprinfo;
- OpclassInfo *opcinfo;
+ int numOpfamilies;
+ int numConversions;
+ int numTSParsers;
+ int numTSTemplates;
+ int numTSDicts;
+ int numTSConfigs;
+ int numForeignDataWrappers;
+ int numForeignServers;
+ int numDefaultACLs;
+ int numEventTriggers;
if (g_verbose)
- write_msg(NULL, "reading namespaces\n");
- nsinfo = getNamespaces(&numNamespaces);
+ 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 types\n");
- tinfo = getTypes(&numTypes);
+ write_msg(NULL, "reading extensions\n");
+ extinfo = getExtensions(fout, &numExtensions);
if (g_verbose)
write_msg(NULL, "reading user-defined functions\n");
- finfo = getFuncs(&numFuncs);
+ 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");
- agginfo = getAggregates(&numAggregates);
+ getAggregates(fout, &numAggregates);
if (g_verbose)
write_msg(NULL, "reading user-defined operators\n");
- oprinfo = getOperators(&numOperators);
+ oprinfo = getOperators(fout, &numOperators);
+ oprinfoindex = buildIndexArray(oprinfo, numOperators, sizeof(OprInfo));
if (g_verbose)
write_msg(NULL, "reading user-defined operator classes\n");
- opcinfo = getOpclasses(&numOpclasses);
+ getOpclasses(fout, &numOpclasses);
if (g_verbose)
- write_msg(NULL, "reading user-defined tables\n");
- tblinfo = getTables(&numTables);
+ write_msg(NULL, "reading user-defined operator families\n");
+ getOpfamilies(fout, &numOpfamilies);
if (g_verbose)
- write_msg(NULL, "reading table inheritance information\n");
- inhinfo = getInherits(&numInherits);
+ write_msg(NULL, "reading user-defined text search parsers\n");
+ getTSParsers(fout, &numTSParsers);
- /* Link tables to parents, mark parents of target tables interesting */
if (g_verbose)
- write_msg(NULL, "finding inheritance relationships\n");
- flagInhTables(tblinfo, numTables, inhinfo, numInherits);
+ write_msg(NULL, "reading user-defined text search templates\n");
+ getTSTemplates(fout, &numTSTemplates);
if (g_verbose)
- write_msg(NULL, "reading column info for interesting tables\n");
- getTableAttrs(tblinfo, numTables);
+ write_msg(NULL, "reading user-defined text search dictionaries\n");
+ getTSDictionaries(fout, &numTSDicts);
if (g_verbose)
- write_msg(NULL, "flagging inherited columns in subtables\n");
- flagInhAttrs(tblinfo, numTables, inhinfo, numInherits);
+ write_msg(NULL, "reading user-defined text search configurations\n");
+ getTSConfigurations(fout, &numTSConfigs);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out database comment\n");
- dumpDBComment(fout);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined foreign-data wrappers\n");
+ getForeignDataWrappers(fout, &numForeignDataWrappers);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined namespaces\n");
- dumpNamespaces(fout, nsinfo, numNamespaces);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined foreign servers\n");
+ getForeignServers(fout, &numForeignServers);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined types\n");
- dumpTypes(fout, finfo, numFuncs, tinfo, numTypes);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading default privileges\n");
+ getDefaultACLs(fout, &numDefaultACLs);
if (g_verbose)
- write_msg(NULL, "dumping out tables\n");
- dumpTables(fout, tblinfo, numTables,
- aclsSkip, schemaOnly, dataOnly);
+ write_msg(NULL, "reading user-defined collations\n");
+ collinfo = getCollations(fout, &numCollations);
+ collinfoindex = buildIndexArray(collinfo, numCollations, sizeof(CollInfo));
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out indexes\n");
- dumpIndexes(fout, tblinfo, numTables);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined conversions\n");
+ getConversions(fout, &numConversions);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined procedural languages\n");
- dumpProcLangs(fout, finfo, numFuncs);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading type casts\n");
+ getCasts(fout, &numCasts);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined functions\n");
- dumpFuncs(fout, finfo, numFuncs);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading table inheritance information\n");
+ inhinfo = getInherits(fout, &numInherits);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined aggregate functions\n");
- dumpAggs(fout, agginfo, numAggregates);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading rewrite rules\n");
+ getRules(fout, &numRules);
+
+ /*
+ * Identify extension member objects and mark them as not to be dumped.
+ * This must happen after reading all objects that can be direct members
+ * of extensions, but before we begin to process table subsidiary objects.
+ */
+ if (g_verbose)
+ write_msg(NULL, "finding extension members\n");
+ getExtensionMembership(fout, extinfo, numExtensions);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined operators\n");
- dumpOprs(fout, oprinfo, numOperators);
- }
+ /* Link tables to parents, mark parents of target tables interesting */
+ if (g_verbose)
+ write_msg(NULL, "finding inheritance relationships\n");
+ flagInhTables(tblinfo, numTables, inhinfo, numInherits);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined operator classes\n");
- dumpOpclasses(fout, opcinfo, numOpclasses);
- }
+ if (g_verbose)
+ write_msg(NULL, "reading column info for interesting tables\n");
+ getTableAttrs(fout, tblinfo, numTables);
- if (!dataOnly)
- {
- if (g_verbose)
- write_msg(NULL, "dumping out user-defined casts\n");
- dumpCasts(fout, finfo, numFuncs, tinfo, numTypes);
- }
+ if (g_verbose)
+ write_msg(NULL, "flagging inherited columns in subtables\n");
+ flagInhAttrs(tblinfo, numTables);
+
+ if (g_verbose)
+ write_msg(NULL, "reading indexes\n");
+ getIndexes(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 event triggers\n");
+ getEventTriggers(fout, &numEventTriggers);
*numTablesPtr = numTables;
return tblinfo;
}
/* flagInhTables -
- * Fill in parentIndexes fields of every target table, and mark
+ * Fill in parent link fields of every target table, and mark
* parents of target tables as interesting
*
* Note that only direct ancestors of targets are marked interesting.
int i,
j;
int numParents;
- int *parentIndexes;
+ TableInfo **parents;
for (i = 0; i < numTables; i++)
{
continue;
/* Don't bother computing anything for non-target tables, either */
- if (!tblinfo[i].dump)
+ if (!tblinfo[i].dobj.dump)
continue;
/* Find all the immediate parent tables */
- findParentsByOid(tblinfo, numTables,
- inhinfo, numInherits,
- tblinfo[i].oid,
- &tblinfo[i].numParents,
- &tblinfo[i].parentIndexes);
- numParents = tblinfo[i].numParents;
- parentIndexes = tblinfo[i].parentIndexes;
+ findParentsByOid(&tblinfo[i], inhinfo, numInherits);
/* Mark the parents as interesting for getTableAttrs */
+ numParents = tblinfo[i].numParents;
+ parents = tblinfo[i].parents;
for (j = 0; j < numParents; j++)
- {
- int parentInd = parentIndexes[j];
-
- tblinfo[parentInd].interesting = true;
- }
+ parents[j]->interesting = true;
}
}
/* flagInhAttrs -
* for each dumpable table in tblinfo, flag its inherited attributes
- * so when we dump the table out, we don't dump out the inherited attributes
+ *
+ * What we need to do here is detect child columns that inherit NOT NULL
+ * bits from their parents (so that we needn't specify that again for the
+ * child) and child columns that have DEFAULT NULL when their parents had
+ * some non-null default. In the latter case, we make up a dummy AttrDefInfo
+ * object so that we'll correctly emit the necessary DEFAULT NULL clause;
+ * otherwise the backend will apply an inherited default to the column.
*
* modifies tblinfo
*/
static void
-flagInhAttrs(TableInfo *tblinfo, int numTables,
- InhInfo *inhinfo, int numInherits)
+flagInhAttrs(TableInfo *tblinfo, int numTables)
{
int i,
j,
k;
- int parentInd;
- int inhAttrInd;
- int numParents;
- int *parentIndexes;
- bool foundAttr; /* Attr was found in a parent */
- bool foundNotNull; /* Attr was NOT NULL in a parent */
- bool defaultsMatch; /* All non-empty defaults match */
- bool defaultsFound; /* Found a default in a parent */
- char *attrDef;
- char *inhDef;
for (i = 0; i < numTables; i++)
{
+ TableInfo *tbinfo = &(tblinfo[i]);
+ int numParents;
+ TableInfo **parents;
+
/* Sequences and views never have parents */
- if (tblinfo[i].relkind == RELKIND_SEQUENCE ||
- tblinfo[i].relkind == RELKIND_VIEW)
+ if (tbinfo->relkind == RELKIND_SEQUENCE ||
+ tbinfo->relkind == RELKIND_VIEW)
continue;
/* Don't bother computing anything for non-target tables, either */
- if (!tblinfo[i].dump)
+ if (!tbinfo->dobj.dump)
continue;
- numParents = tblinfo[i].numParents;
- parentIndexes = tblinfo[i].parentIndexes;
+ numParents = tbinfo->numParents;
+ parents = tbinfo->parents;
if (numParents == 0)
continue; /* nothing to see here, move along */
- /*----------------------------------------------------------------
- * For each attr, check the parent info: if no parent has an attr
- * with the same name, then it's not inherited. If there *is* an
- * attr with the same name, then only dump it if:
- *
- * - it is NOT NULL and zero parents are NOT NULL
- * OR
- * - it has a default value AND the default value does not match
- * all parent default values, or no parents specify a default.
- *
- * See discussion on -hackers around 2-Apr-2001.
- *----------------------------------------------------------------
- */
- for (j = 0; j < tblinfo[i].numatts; j++)
+ /* For each column, search for matching column names in parent(s) */
+ for (j = 0; j < tbinfo->numatts; j++)
{
- foundAttr = false;
- foundNotNull = false;
- defaultsMatch = true;
- defaultsFound = false;
+ bool foundNotNull; /* Attr was NOT NULL in a parent */
+ bool foundDefault; /* Found a default in a parent */
- attrDef = tblinfo[i].adef_expr[j];
+ /* no point in examining dropped columns */
+ if (tbinfo->attisdropped[j])
+ continue;
+ foundNotNull = false;
+ foundDefault = false;
for (k = 0; k < numParents; k++)
{
- parentInd = parentIndexes[k];
- inhAttrInd = strInArray(tblinfo[i].attnames[j],
- tblinfo[parentInd].attnames,
- tblinfo[parentInd].numatts);
+ TableInfo *parent = parents[k];
+ int inhAttrInd;
- if (inhAttrInd != -1)
+ inhAttrInd = strInArray(tbinfo->attnames[j],
+ parent->attnames,
+ parent->numatts);
+ if (inhAttrInd >= 0)
{
- foundAttr = true;
- foundNotNull |= tblinfo[parentInd].notnull[inhAttrInd];
- if (attrDef != NULL) /* If we have a default,
- * check parent */
- {
- inhDef = tblinfo[parentInd].adef_expr[inhAttrInd];
-
- if (inhDef != NULL)
- {
- defaultsFound = true;
- defaultsMatch &= (strcmp(attrDef, inhDef) == 0);
- }
- }
+ foundNotNull |= parent->notnull[inhAttrInd];
+ foundDefault |= (parent->attrdefs[inhAttrInd] != NULL);
}
}
- /*
- * Based on the scan of the parents, decide if we can rely on
- * the inherited attr
- */
- if (foundAttr) /* Attr was inherited */
+ /* Remember if we found inherited NOT NULL */
+ tbinfo->inhNotNull[j] = foundNotNull;
+
+ /* Manufacture a DEFAULT NULL clause if necessary */
+ if (foundDefault && tbinfo->attrdefs[j] == NULL)
{
- /* Set inherited flag by default */
- tblinfo[i].inhAttrs[j] = true;
- tblinfo[i].inhAttrDef[j] = true;
- tblinfo[i].inhNotNull[j] = true;
-
- /*
- * Clear it if attr had a default, but parents did not, or
- * mismatch
- */
- if ((attrDef != NULL) && (!defaultsFound || !defaultsMatch))
+ 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(tbinfo, j))
{
- tblinfo[i].inhAttrs[j] = false;
- tblinfo[i].inhAttrDef[j] = false;
+ attrDef->separate = false;
+ /* No dependency needed: NULL cannot have dependencies */
}
-
- /*
- * Clear it if NOT NULL and none of the parents were NOT
- * NULL
- */
- if (tblinfo[i].notnull[j] && !foundNotNull)
+ else
{
- tblinfo[i].inhAttrs[j] = false;
- tblinfo[i].inhNotNull[j] = false;
+ /* column will be suppressed, print default separately */
+ attrDef->separate = true;
+ /* ensure it comes out after the table */
+ addObjectDependency(&attrDef->dobj,
+ tbinfo->dobj.dumpId);
}
- /* Clear it if attr has local definition */
- if (g_fout->remoteVersion >= 70300 && tblinfo[i].attislocal[j])
- {
- tblinfo[i].inhAttrs[j] = false;
- }
+ tbinfo->attrdefs[j] = attrDef;
}
}
}
}
-
/*
- * findTableByOid
- * finds the index (in tblinfo) of the table with the given oid
- * returns -1 if not found
+ * AssignDumpId
+ * Given a newly-created dumpable object, assign a dump ID,
+ * and enter the object into the lookup table.
*
- * NOTE: should hash this, but just do linear search for now
+ * The caller is expected to have filled in objType and catId,
+ * but not any of the other standard fields of a DumpableObject.
*/
-int
-findTableByOid(TableInfo *tblinfo, int numTables, const char *oid)
+void
+AssignDumpId(DumpableObject *dobj)
{
- int i;
-
- for (i = 0; i < numTables; i++)
+ dobj->dumpId = ++lastDumpId;
+ dobj->name = NULL; /* must be set later */
+ dobj->namespace = NULL; /* may be set later */
+ dobj->dump = true; /* default assumption */
+ dobj->ext_member = false; /* default assumption */
+ dobj->dependencies = NULL;
+ dobj->nDeps = 0;
+ dobj->allocDeps = 0;
+
+ while (dobj->dumpId >= allocedDumpIds)
{
- if (strcmp(tblinfo[i].oid, oid) == 0)
- return i;
+ 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;
}
- return -1;
+ dumpIdMap[dobj->dumpId] = dobj;
+
+ /* mark catalogIdMap invalid, but don't rebuild it yet */
+ catalogIdMapValid = false;
}
+/*
+ * Assign a DumpId that's not tied to a DumpableObject.
+ *
+ * This is used when creating a "fixed" ArchiveEntry that doesn't need to
+ * participate in the sorting logic.
+ */
+DumpId
+createDumpId(void)
+{
+ return ++lastDumpId;
+}
/*
- * findFuncByOid
- * finds the index (in finfo) of the function with the given OID
- * returns -1 if not found
+ * Return the largest DumpId so far assigned
+ */
+DumpId
+getMaxDumpId(void)
+{
+ return lastDumpId;
+}
+
+/*
+ * Find a DumpableObject by dump ID
*
- * NOTE: should hash this, but just do linear search for now
+ * Returns NULL for invalid ID
*/
-int
-findFuncByOid(FuncInfo *finfo, int numFuncs, const char *oid)
+DumpableObject *
+findObjectByDumpId(DumpId dumpId)
{
- int i;
+ if (dumpId <= 0 || dumpId >= allocedDumpIds)
+ return NULL; /* out of range? */
+ return dumpIdMap[dumpId];
+}
- for (i = 0; i < numFuncs; i++)
+/*
+ * Find a DumpableObject by catalog ID
+ *
+ * Returns NULL for unknown ID
+ *
+ * We use binary search in a sorted list that is built on first call.
+ * If AssignDumpId() and findObjectByCatalogId() calls were freely intermixed,
+ * the code would work, but possibly be very slow. In the current usage
+ * pattern that does not happen, indeed we build the list at most twice.
+ */
+DumpableObject *
+findObjectByCatalogId(CatalogId catalogId)
+{
+ DumpableObject **low;
+ DumpableObject **high;
+
+ if (!catalogIdMapValid)
{
- if (strcmp(finfo[i].oid, oid) == 0)
- return i;
+ if (catalogIdMap)
+ free(catalogIdMap);
+ getDumpableObjects(&catalogIdMap, &numCatalogIds);
+ if (numCatalogIds > 1)
+ qsort((void *) catalogIdMap, numCatalogIds,
+ sizeof(DumpableObject *), DOCatalogIdCompare);
+ catalogIdMapValid = true;
}
- return -1;
+
+ /*
+ * 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;
}
/*
- * Finds the index (in tinfo) of the type with the given OID. Returns
- * -1 if not found.
+ * Find a DumpableObject by OID, in a pre-sorted array of one type of object
+ *
+ * Returns NULL for unknown OID
*/
-int
-findTypeByOid(TypeInfo *tinfo, int numTypes, const char *oid)
+static DumpableObject *
+findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
{
+ 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;
+}
+
+/*
+ * Build an index array of DumpableObject pointers, sorted by OID
+ */
+static DumpableObject **
+buildIndexArray(void *objArray, int numObjs, Size objSize)
+{
+ DumpableObject **ptrs;
int i;
- for (i = 0; i < numTypes; 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;
+}
+
+/*
+ * qsort comparator for pointers to DumpableObjects
+ */
+static int
+DOCatalogIdCompare(const void *p1, const void *p2)
+{
+ 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;
+}
+
+/*
+ * Build an array of pointers to all known dumpable objects
+ *
+ * This simply creates a modifiable copy of the internal map.
+ */
+void
+getDumpableObjects(DumpableObject ***objs, int *numObjs)
+{
+ int i,
+ j;
+
+ *objs = (DumpableObject **)
+ pg_malloc(allocedDumpIds * sizeof(DumpableObject *));
+ j = 0;
+ for (i = 1; i < allocedDumpIds; i++)
{
- if (strcmp(tinfo[i].oid, oid) == 0)
- return i;
+ if (dumpIdMap[i])
+ (*objs)[j++] = dumpIdMap[i];
}
- return -1;
+ *numObjs = j;
}
/*
- * findOprByOid
- * given the oid of an operator, return the name of the operator
+ * Add a dependency link to a DumpableObject
*
- * NOTE: should hash this, but just do linear search for now
+ * Note: duplicate dependencies are currently not eliminated
*/
-char *
-findOprByOid(OprInfo *oprinfo, int numOprs, const char *oid)
+void
+addObjectDependency(DumpableObject *dobj, DumpId refId)
+{
+ 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;
+}
+
+/*
+ * Remove a dependency link from a DumpableObject
+ *
+ * If there are multiple links, all are removed
+ */
+void
+removeObjectDependency(DumpableObject *dobj, DumpId refId)
{
int i;
+ int j = 0;
- for (i = 0; i < numOprs; i++)
+ for (i = 0; i < dobj->nDeps; i++)
{
- if (strcmp(oprinfo[i].oid, oid) == 0)
- return oprinfo[i].oprname;
+ if (dobj->dependencies[i] != refId)
+ dobj->dependencies[j++] = dobj->dependencies[i];
}
+ dobj->nDeps = j;
+}
- /* should never get here */
- write_msg(NULL, "failed sanity check, operator with oid %s not found\n", oid);
- /* no suitable operator name was found */
- return (NULL);
+/*
+ * findTableByOid
+ * finds the entry (in tblinfo) of the table with the given oid
+ * returns NULL if not found
+ */
+TableInfo *
+findTableByOid(Oid oid)
+{
+ return (TableInfo *) findObjectByOid(oid, tblinfoindex, numTables);
+}
+
+/*
+ * findTypeByOid
+ * finds the entry (in typinfo) of the type with the given oid
+ * returns NULL if not found
+ */
+TypeInfo *
+findTypeByOid(Oid oid)
+{
+ return (TypeInfo *) findObjectByOid(oid, typinfoindex, numTypes);
}
+/*
+ * findFuncByOid
+ * finds the entry (in funinfo) of the function with the given oid
+ * returns NULL if not found
+ */
+FuncInfo *
+findFuncByOid(Oid oid)
+{
+ return (FuncInfo *) findObjectByOid(oid, funinfoindex, numFuncs);
+}
/*
- * findParentsByOid
- * given the oid of a class, find its parent classes in tblinfo[]
- *
- * Returns the number of parents and their array indexes into the
- * last two arguments.
+ * findOprByOid
+ * finds the entry (in oprinfo) of the operator with the given oid
+ * returns NULL if not found
*/
+OprInfo *
+findOprByOid(Oid oid)
+{
+ return (OprInfo *) findObjectByOid(oid, oprinfoindex, numOperators);
+}
+/*
+ * findCollationByOid
+ * finds the entry (in collinfo) of the collation with the given oid
+ * returns NULL if not found
+ */
+CollInfo *
+findCollationByOid(Oid oid)
+{
+ return (CollInfo *) findObjectByOid(oid, collinfoindex, numCollations);
+}
+
+/*
+ * findNamespaceByOid
+ * finds the entry (in nspinfo) of the namespace with the given oid
+ * returns NULL if not found
+ */
+NamespaceInfo *
+findNamespaceByOid(Oid oid)
+{
+ return (NamespaceInfo *) findObjectByOid(oid, nspinfoindex, numNamespaces);
+}
+
+
+/*
+ * findParentsByOid
+ * find a table's parents in tblinfo[]
+ */
static void
-findParentsByOid(TableInfo *tblinfo, int numTables,
- InhInfo *inhinfo, int numInherits,
- const char *oid,
- int *numParentsPtr, int **parentIndexes)
+findParentsByOid(TableInfo *self,
+ InhInfo *inhinfo, int numInherits)
{
+ Oid oid = self->dobj.catId.oid;
int i,
j;
- int parentInd,
- selfInd;
int numParents;
numParents = 0;
for (i = 0; i < numInherits; i++)
{
- if (strcmp(inhinfo[i].inhrelid, oid) == 0)
+ if (inhinfo[i].inhrelid == oid)
numParents++;
}
- *numParentsPtr = numParents;
+ self->numParents = numParents;
if (numParents > 0)
{
- *parentIndexes = (int *) malloc(sizeof(int) * numParents);
+ self->parents = (TableInfo **)
+ pg_malloc(sizeof(TableInfo *) * numParents);
j = 0;
for (i = 0; i < numInherits; i++)
{
- if (strcmp(inhinfo[i].inhrelid, oid) == 0)
+ if (inhinfo[i].inhrelid == oid)
{
- parentInd = findTableByOid(tblinfo, numTables,
- inhinfo[i].inhparent);
- if (parentInd < 0)
+ TableInfo *parent;
+
+ parent = findTableByOid(inhinfo[i].inhparent);
+ if (parent == NULL)
{
- selfInd = findTableByOid(tblinfo, numTables, oid);
- if (selfInd >= 0)
- write_msg(NULL, "failed sanity check, parent oid %s of table %s (oid %s) not found\n",
- inhinfo[i].inhparent,
- tblinfo[selfInd].relname,
- oid);
- else
- write_msg(NULL, "failed sanity check, parent oid %s of table (oid %s) not found\n",
- inhinfo[i].inhparent,
- oid);
-
- exit_nicely();
+ 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);
}
- (*parentIndexes)[j++] = parentInd;
+ self->parents[j++] = parent;
}
}
}
else
- *parentIndexes = NULL;
+ self->parents = NULL;
}
/*
- * parseNumericArray
+ * parseOidArray
* parse a string of numbers delimited by spaces into a character array
+ *
+ * Note: actually this is used for both Oids and potentially-signed
+ * attribute numbers. This should cause no trouble, but we could split
+ * the function into two functions with different argument types if it does.
*/
void
-parseNumericArray(const char *str, char **array, int arraysize)
+parseOidArray(const char *str, Oid *array, int arraysize)
{
int j,
argNum;
{
if (argNum >= arraysize)
{
- write_msg(NULL, "parseNumericArray: too many numbers\n");
- exit_nicely();
+ write_msg(NULL, "could not parse numeric array \"%s\": too many numbers\n", str);
+ exit_nicely(1);
}
temp[j] = '\0';
- array[argNum++] = strdup(temp);
+ array[argNum++] = atooid(temp);
j = 0;
}
if (s == '\0')
if (!(isdigit((unsigned char) s) || s == '-') ||
j >= sizeof(temp) - 1)
{
- write_msg(NULL, "parseNumericArray: bogus number\n");
- exit_nicely();
+ 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++] = strdup("0");
+ array[argNum++] = InvalidOid;
}
}
return -1;
}
+
+
+/*
+ * Support for simple list operations
+ */
+
+void
+simple_oid_list_append(SimpleOidList *list, Oid val)
+{
+ SimpleOidListCell *cell;
+
+ cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell));
+ cell->next = NULL;
+ cell->val = val;
+
+ if (list->tail)
+ list->tail->next = cell;
+ else
+ list->head = cell;
+ list->tail = cell;
+}
+
+bool
+simple_oid_list_member(SimpleOidList *list, Oid val)
+{
+ SimpleOidListCell *cell;
+
+ for (cell = list->head; cell; cell = cell->next)
+ {
+ if (cell->val == val)
+ return true;
+ }
+ return false;
+}