ignoring errors and call-site error checking.
OBJS= pg_backup_archiver.o pg_backup_db.o pg_backup_custom.o \
pg_backup_files.o pg_backup_null.o pg_backup_tar.o \
- pg_backup_directory.o dumputils.o compress_io.o $(WIN32RES)
+ pg_backup_directory.o common.o dumputils.o compress_io.o $(WIN32RES)
KEYWRDOBJS = keywords.o kwlookup.o
all: pg_dump pg_restore pg_dumpall
-pg_dump: pg_dump.o common.o pg_dump_sort.o $(OBJS) $(KEYWRDOBJS) | submake-libpq submake-libpgport
- $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
+pg_dump: pg_dump.o dumpcatalog.o pg_dump_sort.o $(OBJS) $(KEYWRDOBJS) | submake-libpq submake-libpgport
+ $(CC) $(CFLAGS) pg_dump.o dumpcatalog.o pg_dump_sort.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
pg_restore: pg_restore.o $(OBJS) $(KEYWRDOBJS) | submake-libpq submake-libpgport
$(CC) $(CFLAGS) pg_restore.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
rm -f $(addprefix '$(DESTDIR)$(bindir)'/, pg_dump$(X) pg_restore$(X) pg_dumpall$(X))
clean distclean maintainer-clean:
- rm -f pg_dump$(X) pg_restore$(X) pg_dumpall$(X) $(OBJS) pg_dump.o common.o pg_dump_sort.o pg_restore.o pg_dumpall.o kwlookup.c $(KEYWRDOBJS)
+ rm -f pg_dump$(X) pg_restore$(X) pg_dumpall$(X) $(OBJS) pg_dump.o dumpcatalog.o pg_dump_sort.o pg_restore.o pg_dumpall.o kwlookup.c $(KEYWRDOBJS)
/*-------------------------------------------------------------------------
*
* common.c
- * common routines between pg_dump and pg4_dump
- *
- * Since pg4_dump is long-dead code, there is no longer any useful distinction
- * between this file and pg_dump.c.
+ * common routines between pg_dump and pg_restore (but not pg_dumpall
+ * because there is no failure location to report).
*
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*-------------------------------------------------------------------------
*/
#include "postgres_fe.h"
+#include "pg_backup.h"
+#include "common.h"
#include <ctype.h>
-#include "catalog/pg_class.h"
-
-#include "pg_backup_archiver.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 int numTables;
-static int numTypes;
-static int numFuncs;
-static int numOperators;
-static int numCollations;
-static DumpableObject **tblinfoindex;
-static DumpableObject **typinfoindex;
-static DumpableObject **funinfoindex;
-static DumpableObject **oprinfoindex;
-static DumpableObject **collinfoindex;
-
-
-static void flagInhTables(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);
-
-
-/*
- * getSchemaData
- * Collect information about all potentially dumpable objects
- */
-TableInfo *
-getSchemaData(int *numTablesPtr)
-{
- ExtensionInfo *extinfo;
- InhInfo *inhinfo;
- CollInfo *collinfo;
- int numNamespaces;
- int numExtensions;
- int numAggregates;
- int numInherits;
- int numRules;
- int numProcLangs;
- int numCasts;
- int numOpclasses;
- int numOpfamilies;
- int numConversions;
- int numTSParsers;
- int numTSTemplates;
- int numTSDicts;
- int numTSConfigs;
- int numForeignDataWrappers;
- int numForeignServers;
- int numDefaultACLs;
-
- if (g_verbose)
- write_msg(NULL, "reading schemas\n");
- getNamespaces(&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.
- */
- if (g_verbose)
- write_msg(NULL, "reading user-defined tables\n");
- tblinfo = getTables(&numTables);
- tblinfoindex = buildIndexArray(tblinfo, numTables, sizeof(TableInfo));
-
- if (g_verbose)
- write_msg(NULL, "reading extensions\n");
- extinfo = getExtensions(&numExtensions);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined functions\n");
- funinfo = getFuncs(&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(&numTypes);
- typinfoindex = buildIndexArray(typinfo, numTypes, sizeof(TypeInfo));
-
- /* this must be after getFuncs, too */
- if (g_verbose)
- write_msg(NULL, "reading procedural languages\n");
- getProcLangs(&numProcLangs);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined aggregate functions\n");
- getAggregates(&numAggregates);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined operators\n");
- oprinfo = getOperators(&numOperators);
- oprinfoindex = buildIndexArray(oprinfo, numOperators, sizeof(OprInfo));
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined operator classes\n");
- getOpclasses(&numOpclasses);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined operator families\n");
- getOpfamilies(&numOpfamilies);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined text search parsers\n");
- getTSParsers(&numTSParsers);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined text search templates\n");
- getTSTemplates(&numTSTemplates);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined text search dictionaries\n");
- getTSDictionaries(&numTSDicts);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined text search configurations\n");
- getTSConfigurations(&numTSConfigs);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined foreign-data wrappers\n");
- getForeignDataWrappers(&numForeignDataWrappers);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined foreign servers\n");
- getForeignServers(&numForeignServers);
-
- if (g_verbose)
- write_msg(NULL, "reading default privileges\n");
- getDefaultACLs(&numDefaultACLs);
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined collations\n");
- collinfo = getCollations(&numCollations);
- collinfoindex = buildIndexArray(collinfo, numCollations, sizeof(CollInfo));
-
- if (g_verbose)
- write_msg(NULL, "reading user-defined conversions\n");
- getConversions(&numConversions);
-
- if (g_verbose)
- write_msg(NULL, "reading type casts\n");
- getCasts(&numCasts);
-
- if (g_verbose)
- write_msg(NULL, "reading table inheritance information\n");
- inhinfo = getInherits(&numInherits);
-
- if (g_verbose)
- write_msg(NULL, "reading rewrite rules\n");
- getRules(&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(extinfo, numExtensions);
-
- /* 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 (g_verbose)
- write_msg(NULL, "reading column info for interesting tables\n");
- getTableAttrs(tblinfo, numTables);
-
- 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(tblinfo, numTables);
-
- if (g_verbose)
- write_msg(NULL, "reading constraints\n");
- getConstraints(tblinfo, numTables);
-
- if (g_verbose)
- write_msg(NULL, "reading triggers\n");
- getTriggers(tblinfo, numTables);
-
- *numTablesPtr = numTables;
- return tblinfo;
-}
-
-/* flagInhTables -
- * 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.
- * This is sufficient; we don't much care whether they inherited their
- * attributes or not.
- *
- * modifies tblinfo
- */
-static void
-flagInhTables(TableInfo *tblinfo, int numTables,
- InhInfo *inhinfo, int numInherits)
-{
- int i,
- j;
- int numParents;
- TableInfo **parents;
-
- for (i = 0; i < numTables; i++)
- {
- /* Sequences and views never have parents */
- if (tblinfo[i].relkind == RELKIND_SEQUENCE ||
- tblinfo[i].relkind == RELKIND_VIEW)
- continue;
-
- /* Don't bother computing anything for non-target tables, either */
- if (!tblinfo[i].dobj.dump)
- continue;
-
- /* Find all the immediate parent tables */
- 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++)
- 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
- *
- * modifies tblinfo
- */
-static void
-flagInhAttrs(TableInfo *tblinfo, int numTables)
-{
- int i,
- j,
- k;
-
- for (i = 0; i < numTables; i++)
- {
- TableInfo *tbinfo = &(tblinfo[i]);
- int numParents;
- TableInfo **parents;
- TableInfo *parent;
-
- /* Sequences and views never have parents */
- if (tbinfo->relkind == RELKIND_SEQUENCE ||
- tbinfo->relkind == RELKIND_VIEW)
- 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 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 < tbinfo->numatts; j++)
- {
- 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 */
- AttrDefInfo *attrDef;
-
- foundAttr = false;
- foundNotNull = false;
- defaultsMatch = true;
- defaultsFound = false;
-
- attrDef = tbinfo->attrdefs[j];
-
- for (k = 0; k < numParents; k++)
- {
- int inhAttrInd;
-
- parent = parents[k];
- inhAttrInd = strInArray(tbinfo->attnames[j],
- parent->attnames,
- parent->numatts);
-
- if (inhAttrInd != -1)
- {
- AttrDefInfo *inhDef = parent->attrdefs[inhAttrInd];
-
- foundAttr = true;
- foundNotNull |= parent->notnull[inhAttrInd];
- if (inhDef != NULL)
- {
- defaultsFound = true;
-
- /*
- * If any parent has a default and the child doesn't,
- * we have to emit an explicit DEFAULT NULL clause for
- * the child, else the parent's default will win.
- */
- if (attrDef == NULL)
- {
- attrDef = (AttrDefInfo *) malloc(sizeof(AttrDefInfo));
- attrDef->dobj.objType = DO_ATTRDEF;
- attrDef->dobj.catId.tableoid = 0;
- attrDef->dobj.catId.oid = 0;
- AssignDumpId(&attrDef->dobj);
- attrDef->adtable = tbinfo;
- attrDef->adnum = j + 1;
- attrDef->adef_expr = strdup("NULL");
-
- attrDef->dobj.name = strdup(tbinfo->dobj.name);
- attrDef->dobj.namespace = tbinfo->dobj.namespace;
-
- attrDef->dobj.dump = tbinfo->dobj.dump;
-
- attrDef->separate = false;
- addObjectDependency(&tbinfo->dobj,
- attrDef->dobj.dumpId);
-
- tbinfo->attrdefs[j] = attrDef;
- }
- if (strcmp(attrDef->adef_expr, inhDef->adef_expr) != 0)
- {
- defaultsMatch = false;
-
- /*
- * Whenever there is a non-matching parent
- * default, add a dependency to force the parent
- * default to be dumped first, in case the
- * defaults end up being dumped as separate
- * commands. Otherwise the parent default will
- * override the child's when it is applied.
- */
- addObjectDependency(&attrDef->dobj,
- inhDef->dobj.dumpId);
- }
- }
- }
- }
-
- /*
- * Based on the scan of the parents, decide if we can rely on the
- * inherited attr
- */
- if (foundAttr) /* Attr was inherited */
- {
- /* Set inherited flag by default */
- tbinfo->inhAttrs[j] = true;
- tbinfo->inhAttrDef[j] = true;
- tbinfo->inhNotNull[j] = true;
-
- /*
- * Clear it if attr had a default, but parents did not, or
- * mismatch
- */
- if ((attrDef != NULL) && (!defaultsFound || !defaultsMatch))
- {
- tbinfo->inhAttrs[j] = false;
- tbinfo->inhAttrDef[j] = false;
- }
-
- /*
- * Clear it if NOT NULL and none of the parents were NOT NULL
- */
- if (tbinfo->notnull[j] && !foundNotNull)
- {
- tbinfo->inhAttrs[j] = false;
- tbinfo->inhNotNull[j] = false;
- }
-
- /* Clear it if attr has local definition */
- if (tbinfo->attislocal[j])
- tbinfo->inhAttrs[j] = false;
- }
- }
- }
-}
-
-/*
- * AssignDumpId
- * Given a newly-created dumpable object, assign a dump ID,
- * and enter the object into the lookup table.
- *
- * The caller is expected to have filled in objType and catId,
- * but not any of the other standard fields of a DumpableObject.
- */
-void
-AssignDumpId(DumpableObject *dobj)
-{
- 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)
- {
- 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;
-}
-
-/*
- * 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;
-}
-
-/*
- * Return the largest DumpId so far assigned
- */
-DumpId
-getMaxDumpId(void)
-{
- return lastDumpId;
-}
-
-/*
- * Find a DumpableObject by dump ID
- *
- * Returns NULL for invalid ID
- */
-DumpableObject *
-findObjectByDumpId(DumpId dumpId)
-{
- if (dumpId <= 0 || dumpId >= allocedDumpIds)
- return NULL; /* out of range? */
- return dumpIdMap[dumpId];
-}
-
-/*
- * 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 (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;
-}
-
-/*
- * Find a DumpableObject by OID, in a pre-sorted array of one type of object
- *
- * Returns NULL for unknown 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;
-
- ptrs = (DumpableObject **) 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 (dumpIdMap[i])
- (*objs)[j++] = dumpIdMap[i];
- }
- *numObjs = j;
-}
-
-/*
- * Add a dependency link to a DumpableObject
- *
- * Note: duplicate dependencies are currently not eliminated
- */
-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 < dobj->nDeps; i++)
- {
- if (dobj->dependencies[i] != refId)
- dobj->dependencies[j++] = dobj->dependencies[i];
- }
- dobj->nDeps = j;
-}
-
-
-/*
- * 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);
-}
-
-/*
- * 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);
-}
-
-
-/*
- * findParentsByOid
- * find a table's parents in tblinfo[]
- */
-static void
-findParentsByOid(TableInfo *self,
- InhInfo *inhinfo, int numInherits)
-{
- 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();
- }
- self->parents[j++] = parent;
- }
- }
- }
- else
- self->parents = NULL;
-}
-
-/*
- * 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
-parseOidArray(const char *str, Oid *array, int arraysize)
-{
- 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();
- }
- 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();
- }
- temp[j++] = s;
- }
- }
-
- while (argNum < arraysize)
- array[argNum++] = InvalidOid;
-}
-
-
-/*
- * strInArray:
- * takes in a string and a string array and the number of elements in the
- * string array.
- * returns the index if the string is somewhere in the array, -1 otherwise
- */
-
-static int
-strInArray(const char *pattern, char **arr, int arr_size)
-{
- int i;
-
- for (i = 0; i < arr_size; i++)
- {
- if (strcmp(pattern, arr[i]) == 0)
- return i;
- }
- 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;
-}
-
-void
-simple_string_list_append(SimpleStringList *list, const char *val)
-{
- SimpleStringListCell *cell;
-
- /* this calculation correctly accounts for the null trailing byte */
- cell = (SimpleStringListCell *)
- pg_malloc(sizeof(SimpleStringListCell) + strlen(val));
- cell->next = NULL;
- strcpy(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;
-}
-
-bool
-simple_string_list_member(SimpleStringList *list, const char *val)
-{
- SimpleStringListCell *cell;
-
- for (cell = list->head; cell; cell = cell->next)
- {
- if (strcmp(cell->val, val) == 0)
- return true;
- }
- return false;
-}
-
-
/*
* Safer versions of some standard C library functions. If an
* out-of-memory condition occurs, these functions will bail out
* safely; therefore, their return value is guaranteed to be non-NULL.
- *
- * XXX need to refactor things so that these can be in a file that can be
- * shared by pg_dumpall and pg_restore as well as pg_dump.
+ * We also report the program name and close the database connection.
*/
char *
tmp = calloc(nmemb, size);
if (!tmp)
- exit_horribly(NULL, NULL, "out of memory\n");
+ exit_horribly(NULL, NULL, _("out of memory\n"));
return tmp;
}
tmp = realloc(ptr, size);
if (!tmp)
- exit_horribly(NULL, NULL, "out of memory\n");
+ exit_horribly(NULL, NULL, _("out of memory\n"));
return tmp;
}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * common.h
+ * Common header file for the pg_dump, pg_dumpall, and pg_restore
+ *
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/bin/pg_dump/common.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include "postgres_fe.h"
+
+extern char *pg_strdup(const char *string);
+extern void *pg_malloc(size_t size);
+extern void *pg_calloc(size_t nmemb, size_t size);
+extern void *pg_realloc(void *ptr, size_t size);
+
+#endif /* COMMON_H */
*/
#include "compress_io.h"
+#include "common.h"
/*----------------------
* Compressor API
die_horribly(NULL, modulename, "not built with zlib support\n");
#endif
- cs = (CompressorState *) calloc(1, sizeof(CompressorState));
- if (cs == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ cs = (CompressorState *) pg_calloc(1, sizeof(CompressorState));
cs->writeF = writeF;
cs->comprAlg = alg;
{
z_streamp zp;
- zp = cs->zp = (z_streamp) malloc(sizeof(z_stream));
- if (cs->zp == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ zp = cs->zp = (z_streamp) pg_malloc(sizeof(z_stream));
zp->zalloc = Z_NULL;
zp->zfree = Z_NULL;
zp->opaque = Z_NULL;
* actually allocate one extra byte because some routines want to append a
* trailing zero byte to the zlib output.
*/
- cs->zlibOut = (char *) malloc(ZLIB_OUT_SIZE + 1);
+ cs->zlibOut = (char *) pg_malloc(ZLIB_OUT_SIZE + 1);
cs->zlibOutSize = ZLIB_OUT_SIZE;
- if (cs->zlibOut == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
-
if (deflateInit(zp, level) != Z_OK)
die_horribly(NULL, modulename,
"could not initialize compression library: %s\n",
char *buf;
size_t buflen;
- zp = (z_streamp) malloc(sizeof(z_stream));
- if (zp == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ zp = (z_streamp) pg_malloc(sizeof(z_stream));
zp->zalloc = Z_NULL;
zp->zfree = Z_NULL;
zp->opaque = Z_NULL;
- buf = malloc(ZLIB_IN_SIZE);
- if (buf == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ buf = pg_malloc(ZLIB_IN_SIZE);
buflen = ZLIB_IN_SIZE;
- out = malloc(ZLIB_OUT_SIZE + 1);
- if (out == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ out = pg_malloc(ZLIB_OUT_SIZE + 1);
if (inflateInit(zp) != Z_OK)
die_horribly(NULL, modulename,
char *buf;
size_t buflen;
- buf = malloc(ZLIB_OUT_SIZE);
- if (buf == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ buf = pg_malloc(ZLIB_OUT_SIZE);
buflen = ZLIB_OUT_SIZE;
while ((cnt = readF(AH, &buf, &buflen)))
if (fp == NULL)
{
int fnamelen = strlen(path) + 4;
- char *fname = malloc(fnamelen);
-
- if (fname == NULL)
- die_horribly(NULL, modulename, "Out of memory\n");
+ char *fname = pg_malloc(fnamelen);
snprintf(fname, fnamelen, "%s%s", path, ".gz");
fp = cfopen(fname, mode, 1);
{
#ifdef HAVE_LIBZ
int fnamelen = strlen(path) + 4;
- char *fname = malloc(fnamelen);
-
- if (fname == NULL)
- die_horribly(NULL, modulename, "Out of memory\n");
+ char *fname = pg_malloc(fnamelen);
snprintf(fname, fnamelen, "%s%s", path, ".gz");
fp = cfopen(fname, mode, 1);
cfp *
cfopen(const char *path, const char *mode, int compression)
{
- cfp *fp = malloc(sizeof(cfp));
-
- if (fp == NULL)
- die_horribly(NULL, modulename, "Out of memory\n");
+ cfp *fp = pg_malloc(sizeof(cfp));
if (compression != 0)
{
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * common.c
+ * catalog routines used by pg_dump
+ *
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * src/bin/pg_dump/dumpcatalog.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres_fe.h"
+
+#include <ctype.h>
+
+#include "catalog/pg_class.h"
+
+#include "pg_backup_archiver.h"
+#include "common.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 int numTables;
+static int numTypes;
+static int numFuncs;
+static int numOperators;
+static int numCollations;
+static DumpableObject **tblinfoindex;
+static DumpableObject **typinfoindex;
+static DumpableObject **funinfoindex;
+static DumpableObject **oprinfoindex;
+static DumpableObject **collinfoindex;
+
+
+static void flagInhTables(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);
+
+
+/*
+ * getSchemaData
+ * Collect information about all potentially dumpable objects
+ */
+TableInfo *
+getSchemaData(int *numTablesPtr)
+{
+ ExtensionInfo *extinfo;
+ InhInfo *inhinfo;
+ CollInfo *collinfo;
+ int numNamespaces;
+ int numExtensions;
+ int numAggregates;
+ int numInherits;
+ int numRules;
+ int numProcLangs;
+ int numCasts;
+ int numOpclasses;
+ int numOpfamilies;
+ int numConversions;
+ int numTSParsers;
+ int numTSTemplates;
+ int numTSDicts;
+ int numTSConfigs;
+ int numForeignDataWrappers;
+ int numForeignServers;
+ int numDefaultACLs;
+
+ if (g_verbose)
+ write_msg(NULL, "reading schemas\n");
+ getNamespaces(&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.
+ */
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined tables\n");
+ tblinfo = getTables(&numTables);
+ tblinfoindex = buildIndexArray(tblinfo, numTables, sizeof(TableInfo));
+
+ if (g_verbose)
+ write_msg(NULL, "reading extensions\n");
+ extinfo = getExtensions(&numExtensions);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined functions\n");
+ funinfo = getFuncs(&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(&numTypes);
+ typinfoindex = buildIndexArray(typinfo, numTypes, sizeof(TypeInfo));
+
+ /* this must be after getFuncs, too */
+ if (g_verbose)
+ write_msg(NULL, "reading procedural languages\n");
+ getProcLangs(&numProcLangs);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined aggregate functions\n");
+ getAggregates(&numAggregates);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined operators\n");
+ oprinfo = getOperators(&numOperators);
+ oprinfoindex = buildIndexArray(oprinfo, numOperators, sizeof(OprInfo));
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined operator classes\n");
+ getOpclasses(&numOpclasses);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined operator families\n");
+ getOpfamilies(&numOpfamilies);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined text search parsers\n");
+ getTSParsers(&numTSParsers);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined text search templates\n");
+ getTSTemplates(&numTSTemplates);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined text search dictionaries\n");
+ getTSDictionaries(&numTSDicts);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined text search configurations\n");
+ getTSConfigurations(&numTSConfigs);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined foreign-data wrappers\n");
+ getForeignDataWrappers(&numForeignDataWrappers);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined foreign servers\n");
+ getForeignServers(&numForeignServers);
+
+ if (g_verbose)
+ write_msg(NULL, "reading default privileges\n");
+ getDefaultACLs(&numDefaultACLs);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined collations\n");
+ collinfo = getCollations(&numCollations);
+ collinfoindex = buildIndexArray(collinfo, numCollations, sizeof(CollInfo));
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined conversions\n");
+ getConversions(&numConversions);
+
+ if (g_verbose)
+ write_msg(NULL, "reading type casts\n");
+ getCasts(&numCasts);
+
+ if (g_verbose)
+ write_msg(NULL, "reading table inheritance information\n");
+ inhinfo = getInherits(&numInherits);
+
+ if (g_verbose)
+ write_msg(NULL, "reading rewrite rules\n");
+ getRules(&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(extinfo, numExtensions);
+
+ /* 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 (g_verbose)
+ write_msg(NULL, "reading column info for interesting tables\n");
+ getTableAttrs(tblinfo, numTables);
+
+ 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(tblinfo, numTables);
+
+ if (g_verbose)
+ write_msg(NULL, "reading constraints\n");
+ getConstraints(tblinfo, numTables);
+
+ if (g_verbose)
+ write_msg(NULL, "reading triggers\n");
+ getTriggers(tblinfo, numTables);
+
+ *numTablesPtr = numTables;
+ return tblinfo;
+}
+
+/* flagInhTables -
+ * 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.
+ * This is sufficient; we don't much care whether they inherited their
+ * attributes or not.
+ *
+ * modifies tblinfo
+ */
+static void
+flagInhTables(TableInfo *tblinfo, int numTables,
+ InhInfo *inhinfo, int numInherits)
+{
+ int i,
+ j;
+ int numParents;
+ TableInfo **parents;
+
+ for (i = 0; i < numTables; i++)
+ {
+ /* Sequences and views never have parents */
+ if (tblinfo[i].relkind == RELKIND_SEQUENCE ||
+ tblinfo[i].relkind == RELKIND_VIEW)
+ continue;
+
+ /* Don't bother computing anything for non-target tables, either */
+ if (!tblinfo[i].dobj.dump)
+ continue;
+
+ /* Find all the immediate parent tables */
+ 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++)
+ 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
+ *
+ * modifies tblinfo
+ */
+static void
+flagInhAttrs(TableInfo *tblinfo, int numTables)
+{
+ int i,
+ j,
+ k;
+
+ for (i = 0; i < numTables; i++)
+ {
+ TableInfo *tbinfo = &(tblinfo[i]);
+ int numParents;
+ TableInfo **parents;
+ TableInfo *parent;
+
+ /* Sequences and views never have parents */
+ if (tbinfo->relkind == RELKIND_SEQUENCE ||
+ tbinfo->relkind == RELKIND_VIEW)
+ 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 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 < tbinfo->numatts; j++)
+ {
+ 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 */
+ AttrDefInfo *attrDef;
+
+ foundAttr = false;
+ foundNotNull = false;
+ defaultsMatch = true;
+ defaultsFound = false;
+
+ attrDef = tbinfo->attrdefs[j];
+
+ for (k = 0; k < numParents; k++)
+ {
+ int inhAttrInd;
+
+ parent = parents[k];
+ inhAttrInd = strInArray(tbinfo->attnames[j],
+ parent->attnames,
+ parent->numatts);
+
+ if (inhAttrInd != -1)
+ {
+ AttrDefInfo *inhDef = parent->attrdefs[inhAttrInd];
+
+ foundAttr = true;
+ foundNotNull |= parent->notnull[inhAttrInd];
+ if (inhDef != NULL)
+ {
+ defaultsFound = true;
+
+ /*
+ * If any parent has a default and the child doesn't,
+ * we have to emit an explicit DEFAULT NULL clause for
+ * the child, else the parent's default will win.
+ */
+ if (attrDef == NULL)
+ {
+ 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->adtable = tbinfo;
+ attrDef->adnum = j + 1;
+ attrDef->adef_expr = pg_strdup("NULL");
+
+ attrDef->dobj.name = pg_strdup(tbinfo->dobj.name);
+ attrDef->dobj.namespace = tbinfo->dobj.namespace;
+
+ attrDef->dobj.dump = tbinfo->dobj.dump;
+
+ attrDef->separate = false;
+ addObjectDependency(&tbinfo->dobj,
+ attrDef->dobj.dumpId);
+
+ tbinfo->attrdefs[j] = attrDef;
+ }
+ if (strcmp(attrDef->adef_expr, inhDef->adef_expr) != 0)
+ {
+ defaultsMatch = false;
+
+ /*
+ * Whenever there is a non-matching parent
+ * default, add a dependency to force the parent
+ * default to be dumped first, in case the
+ * defaults end up being dumped as separate
+ * commands. Otherwise the parent default will
+ * override the child's when it is applied.
+ */
+ addObjectDependency(&attrDef->dobj,
+ inhDef->dobj.dumpId);
+ }
+ }
+ }
+ }
+
+ /*
+ * Based on the scan of the parents, decide if we can rely on the
+ * inherited attr
+ */
+ if (foundAttr) /* Attr was inherited */
+ {
+ /* Set inherited flag by default */
+ tbinfo->inhAttrs[j] = true;
+ tbinfo->inhAttrDef[j] = true;
+ tbinfo->inhNotNull[j] = true;
+
+ /*
+ * Clear it if attr had a default, but parents did not, or
+ * mismatch
+ */
+ if ((attrDef != NULL) && (!defaultsFound || !defaultsMatch))
+ {
+ tbinfo->inhAttrs[j] = false;
+ tbinfo->inhAttrDef[j] = false;
+ }
+
+ /*
+ * Clear it if NOT NULL and none of the parents were NOT NULL
+ */
+ if (tbinfo->notnull[j] && !foundNotNull)
+ {
+ tbinfo->inhAttrs[j] = false;
+ tbinfo->inhNotNull[j] = false;
+ }
+
+ /* Clear it if attr has local definition */
+ if (tbinfo->attislocal[j])
+ tbinfo->inhAttrs[j] = false;
+ }
+ }
+ }
+}
+
+/*
+ * AssignDumpId
+ * Given a newly-created dumpable object, assign a dump ID,
+ * and enter the object into the lookup table.
+ *
+ * The caller is expected to have filled in objType and catId,
+ * but not any of the other standard fields of a DumpableObject.
+ */
+void
+AssignDumpId(DumpableObject *dobj)
+{
+ 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)
+ {
+ 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;
+}
+
+/*
+ * 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;
+}
+
+/*
+ * Return the largest DumpId so far assigned
+ */
+DumpId
+getMaxDumpId(void)
+{
+ return lastDumpId;
+}
+
+/*
+ * Find a DumpableObject by dump ID
+ *
+ * Returns NULL for invalid ID
+ */
+DumpableObject *
+findObjectByDumpId(DumpId dumpId)
+{
+ if (dumpId <= 0 || dumpId >= allocedDumpIds)
+ return NULL; /* out of range? */
+ return dumpIdMap[dumpId];
+}
+
+/*
+ * 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 (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;
+}
+
+/*
+ * Find a DumpableObject by OID, in a pre-sorted array of one type of object
+ *
+ * Returns NULL for unknown 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;
+
+ 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 (dumpIdMap[i])
+ (*objs)[j++] = dumpIdMap[i];
+ }
+ *numObjs = j;
+}
+
+/*
+ * Add a dependency link to a DumpableObject
+ *
+ * Note: duplicate dependencies are currently not eliminated
+ */
+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 < dobj->nDeps; i++)
+ {
+ if (dobj->dependencies[i] != refId)
+ dobj->dependencies[j++] = dobj->dependencies[i];
+ }
+ dobj->nDeps = j;
+}
+
+
+/*
+ * 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);
+}
+
+/*
+ * 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);
+}
+
+
+/*
+ * findParentsByOid
+ * find a table's parents in tblinfo[]
+ */
+static void
+findParentsByOid(TableInfo *self,
+ InhInfo *inhinfo, int numInherits)
+{
+ 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();
+ }
+ self->parents[j++] = parent;
+ }
+ }
+ }
+ else
+ self->parents = NULL;
+}
+
+/*
+ * 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
+parseOidArray(const char *str, Oid *array, int arraysize)
+{
+ 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();
+ }
+ 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();
+ }
+ temp[j++] = s;
+ }
+ }
+
+ while (argNum < arraysize)
+ array[argNum++] = InvalidOid;
+}
+
+
+/*
+ * strInArray:
+ * takes in a string and a string array and the number of elements in the
+ * string array.
+ * returns the index if the string is somewhere in the array, -1 otherwise
+ */
+
+static int
+strInArray(const char *pattern, char **arr, int arr_size)
+{
+ int i;
+
+ for (i = 0; i < arr_size; i++)
+ {
+ if (strcmp(pattern, arr[i]) == 0)
+ return i;
+ }
+ 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;
+}
+
+void
+simple_string_list_append(SimpleStringList *list, const char *val)
+{
+ SimpleStringListCell *cell;
+
+ /* this calculation correctly accounts for the null trailing byte */
+ cell = (SimpleStringListCell *)
+ pg_malloc(sizeof(SimpleStringListCell) + strlen(val));
+ cell->next = NULL;
+ strcpy(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;
+}
+
+bool
+simple_string_list_member(SimpleStringList *list, const char *val)
+{
+ SimpleStringListCell *cell;
+
+ for (cell = list->head; cell; cell = cell->next)
+ {
+ if (strcmp(cell->val, val) == 0)
+ return true;
+ }
+ return false;
+}
#include <ctype.h>
+#include "common.h"
#include "dumputils.h"
#include "parser/keywords.h"
*/
#include "pg_backup_db.h"
+#include "common.h"
#include "dumputils.h"
#include <ctype.h>
{
ahlog(AH, 1, "connecting to new database \"%s\"\n", te->tag);
_reconnectToDB(AH, te->tag);
- ropt->dbname = strdup(te->tag);
+ ropt->dbname = pg_strdup(te->tag);
}
}
{
RestoreOptions *opts;
- opts = (RestoreOptions *) calloc(1, sizeof(RestoreOptions));
+ opts = (RestoreOptions *) pg_calloc(1, sizeof(RestoreOptions));
/* set any fields that shouldn't default to zeroes */
opts->format = archUnknown;
ArchiveHandle *AH = (ArchiveHandle *) AHX;
TocEntry *newToc;
- newToc = (TocEntry *) calloc(1, sizeof(TocEntry));
- if (!newToc)
- die_horribly(AH, modulename, "out of memory\n");
+ newToc = (TocEntry *) pg_calloc(1, sizeof(TocEntry));
AH->tocCount++;
if (dumpId > AH->maxDumpId)
newToc->dumpId = dumpId;
newToc->section = section;
- newToc->tag = strdup(tag);
- newToc->namespace = namespace ? strdup(namespace) : NULL;
- newToc->tablespace = tablespace ? strdup(tablespace) : NULL;
- newToc->owner = strdup(owner);
+ newToc->tag = pg_strdup(tag);
+ newToc->namespace = namespace ? pg_strdup(namespace) : NULL;
+ newToc->tablespace = tablespace ? pg_strdup(tablespace) : NULL;
+ newToc->owner = pg_strdup(owner);
newToc->withOids = withOids;
- newToc->desc = strdup(desc);
- newToc->defn = strdup(defn);
- newToc->dropStmt = strdup(dropStmt);
- newToc->copyStmt = copyStmt ? strdup(copyStmt) : NULL;
+ newToc->desc = pg_strdup(desc);
+ newToc->defn = pg_strdup(defn);
+ newToc->dropStmt = pg_strdup(dropStmt);
+ newToc->copyStmt = copyStmt ? pg_strdup(copyStmt) : NULL;
if (nDeps > 0)
{
- newToc->dependencies = (DumpId *) malloc(nDeps * sizeof(DumpId));
+ newToc->dependencies = (DumpId *) pg_malloc(nDeps * sizeof(DumpId));
memcpy(newToc->dependencies, deps, nDeps * sizeof(DumpId));
newToc->nDeps = nDeps;
}
bool incomplete_line;
/* Allocate space for the 'wanted' array, and init it */
- ropt->idWanted = (bool *) malloc(sizeof(bool) * AH->maxDumpId);
+ ropt->idWanted = (bool *) pg_malloc(sizeof(bool) * AH->maxDumpId);
memset(ropt->idWanted, 0, sizeof(bool) * AH->maxDumpId);
/* Setup the file */
ArchiveHandle *AH = (ArchiveHandle *) AHX;
/* Allocate space for the 'wanted' array, and init it to 1's */
- ropt->idWanted = (bool *) malloc(sizeof(bool) * AH->maxDumpId);
+ ropt->idWanted = (bool *) pg_malloc(sizeof(bool) * AH->maxDumpId);
memset(ropt->idWanted, 1, sizeof(bool) * AH->maxDumpId);
}
if (p != NULL)
free(p);
bSize *= 2;
- p = (char *) malloc(bSize);
- if (p == NULL)
- exit_horribly(AH, modulename, "out of memory\n");
+ p = (char *) pg_malloc(bSize);
va_start(ap, fmt);
cnt = vsnprintf(p, bSize, fmt, ap);
va_end(ap);
if (p != NULL)
free(p);
bSize *= 2;
- p = (char *) malloc(bSize);
- if (p == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ p = (char *) pg_malloc(bSize);
va_start(ap, fmt);
cnt = vsnprintf(p, bSize, fmt, ap);
va_end(ap);
buf = NULL;
else
{
- buf = (char *) malloc(l + 1);
- if (!buf)
- die_horribly(AH, modulename, "out of memory\n");
-
+ buf = (char *) pg_malloc(l + 1);
if ((*AH->ReadBufPtr) (AH, (void *) buf, l) != l)
die_horribly(AH, modulename, "unexpected end of file\n");
free(AH->lookahead);
AH->lookaheadSize = 512;
- AH->lookahead = calloc(1, 512);
+ AH->lookahead = pg_calloc(1, 512);
AH->lookaheadLen = 0;
AH->lookaheadPos = 0;
write_msg(modulename, "allocating AH for %s, format %d\n", FileSpec, fmt);
#endif
- AH = (ArchiveHandle *) calloc(1, sizeof(ArchiveHandle));
- if (!AH)
- die_horribly(AH, modulename, "out of memory\n");
+ AH = (ArchiveHandle *) pg_calloc(1, sizeof(ArchiveHandle));
/* AH->debugLevel = 100; */
AH->offSize = sizeof(pgoff_t);
if (FileSpec)
{
- AH->fSpec = strdup(FileSpec);
+ AH->fSpec = pg_strdup(FileSpec);
/*
* Not used; maybe later....
*
- * AH->workDir = strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
+ * AH->workDir = pg_strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
* i--) if (AH->workDir[i-1] == '/')
*/
}
AH->currTablespace = NULL; /* ditto */
AH->currWithOids = -1; /* force SET */
- AH->toc = (TocEntry *) calloc(1, sizeof(TocEntry));
- if (!AH->toc)
- die_horribly(AH, modulename, "out of memory\n");
+ AH->toc = (TocEntry *) pg_calloc(1, sizeof(TocEntry));
AH->toc->next = AH->toc;
AH->toc->prev = AH->toc;
for (i = 0; i < AH->tocCount; i++)
{
- te = (TocEntry *) calloc(1, sizeof(TocEntry));
+ te = (TocEntry *) pg_calloc(1, sizeof(TocEntry));
te->dumpId = ReadInt(AH);
if (te->dumpId > AH->maxDumpId)
if (AH->version >= K_VERS_1_5)
{
depSize = 100;
- deps = (DumpId *) malloc(sizeof(DumpId) * depSize);
+ deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
depIdx = 0;
for (;;)
{
processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
{
/* te->defn should have the form SET client_encoding = 'foo'; */
- char *defn = strdup(te->defn);
+ char *defn = pg_strdup(te->defn);
char *ptr1;
char *ptr2 = NULL;
int encoding;
*/
if (AH->currUser)
free(AH->currUser);
- AH->currUser = strdup(user);
+ AH->currUser = pg_strdup(user);
}
/*
if (AH->currSchema)
free(AH->currSchema);
- AH->currSchema = strdup(schemaName);
+ AH->currSchema = pg_strdup(schemaName);
destroyPQExpBuffer(qry);
}
if (AH->currTablespace)
free(AH->currTablespace);
- AH->currTablespace = strdup(want);
+ AH->currTablespace = pg_strdup(want);
destroyPQExpBuffer(qry);
}
strcmp(type, "OPERATOR FAMILY") == 0)
{
/* Chop "DROP " off the front and make a modifiable copy */
- char *first = strdup(te->dropStmt + 5);
+ char *first = pg_strdup(te->dropStmt + 5);
char *last;
/* point to last character in string */
ahlog(AH, 2, "entering restore_toc_entries_parallel\n");
- slots = (ParallelSlot *) calloc(sizeof(ParallelSlot), n_slots);
+ slots = (ParallelSlot *) pg_calloc(sizeof(ParallelSlot), n_slots);
/* Adjust dependency information */
fix_dependencies(AH);
par_list_remove(next_work_item);
/* this memory is dealloced in mark_work_done() */
- args = malloc(sizeof(RestoreArgs));
+ args = pg_malloc(sizeof(RestoreArgs));
args->AH = CloneArchive(AH);
args->te = next_work_item;
/* first time around only, make space for handles to listen on */
if (handles == NULL)
- handles = (HANDLE *) calloc(sizeof(HANDLE), n_slots);
+ handles = (HANDLE *) pg_calloc(sizeof(HANDLE), n_slots);
/* set up list of handles to listen to */
for (snum = 0, tnum = 0; snum < n_slots; snum++)
* the TOC items are marked as not being in any parallel-processing list.
*/
maxDumpId = AH->maxDumpId;
- tocsByDumpId = (TocEntry **) calloc(maxDumpId, sizeof(TocEntry *));
+ tocsByDumpId = (TocEntry **) pg_calloc(maxDumpId, sizeof(TocEntry *));
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
tocsByDumpId[te->dumpId - 1] = te;
{
if (strcmp(te2->desc, "BLOBS") == 0)
{
- te->dependencies = (DumpId *) malloc(sizeof(DumpId));
+ te->dependencies = (DumpId *) pg_malloc(sizeof(DumpId));
te->dependencies[0] = te2->dumpId;
te->nDeps++;
te->depCount++;
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
if (te->nRevDeps > 0)
- te->revDeps = (DumpId *) malloc(te->nRevDeps * sizeof(DumpId));
+ te->revDeps = (DumpId *) pg_malloc(te->nRevDeps * sizeof(DumpId));
te->nRevDeps = 0;
}
* that all the entry types we are interested in here are POST_DATA, so
* they will all have been changed this way.)
*/
- lockids = (DumpId *) malloc(te->nDeps * sizeof(DumpId));
+ lockids = (DumpId *) pg_malloc(te->nDeps * sizeof(DumpId));
nlockids = 0;
for (i = 0; i < te->nDeps; i++)
{
ArchiveHandle *clone;
/* Make a "flat" copy */
- clone = (ArchiveHandle *) malloc(sizeof(ArchiveHandle));
- if (clone == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
memcpy(clone, AH, sizeof(ArchiveHandle));
/* Handle format-independent fields ... none at the moment */
/* savedPassword must be local in case we change it while connecting */
if (clone->savedPassword)
- clone->savedPassword = strdup(clone->savedPassword);
+ clone->savedPassword = pg_strdup(clone->savedPassword);
/* clone has its own error count, too */
clone->public.n_errors = 0;
*/
#include "compress_io.h"
+#include "common.h"
/*--------
* Routines in the format interface
AH->DeClonePtr = _DeClone;
/* Set up a private area. */
- ctx = (lclContext *) calloc(1, sizeof(lclContext));
- if (ctx == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ ctx = (lclContext *) pg_calloc(1, sizeof(lclContext));
AH->formatData = (void *) ctx;
/* Initialize LO buffering */
AH->lo_buf_size = LOBBUFSIZE;
- AH->lo_buf = (void *) malloc(LOBBUFSIZE);
- if (AH->lo_buf == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
ctx->filePos = 0;
{
lclTocEntry *ctx;
- ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
+ ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
if (te->dataDumper)
ctx->dataState = K_OFFSET_POS_NOT_SET;
else
if (ctx == NULL)
{
- ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
+ ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
te->formatData = (void *) ctx;
}
{
if (buf)
free(buf);
- buf = (char *) malloc(blkLen);
+ buf = (char *) pg_malloc(blkLen);
buflen = blkLen;
}
cnt = fread(buf, 1, blkLen, AH->FH);
{
lclContext *ctx = (lclContext *) AH->formatData;
- AH->formatData = (lclContext *) malloc(sizeof(lclContext));
- if (AH->formatData == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ AH->formatData = (lclContext *) pg_malloc(sizeof(lclContext));
memcpy(AH->formatData, ctx, sizeof(lclContext));
ctx = (lclContext *) AH->formatData;
if (blkLen > *buflen)
{
free(*buf);
- *buf = (char *) malloc(blkLen);
- if (!(*buf))
- die_horribly(AH, modulename, "out of memory\n");
+ *buf = (char *) pg_malloc(blkLen);
*buflen = blkLen;
}
*/
#include "pg_backup_db.h"
+#include "common.h"
#include "dumputils.h"
#include <unistd.h>
remoteversion = _parse_version(AH, remoteversion_str);
- AH->public.remoteVersionStr = strdup(remoteversion_str);
+ AH->public.remoteVersionStr = pg_strdup(remoteversion_str);
AH->public.remoteVersion = remoteversion;
if (!AH->archiveRemoteVersion)
AH->archiveRemoteVersion = AH->public.remoteVersionStr;
do
{
#define PARAMS_ARRAY_SIZE 7
- const char **keywords = malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
- const char **values = malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
-
- if (!keywords || !values)
- die_horribly(AH, modulename, "out of memory\n");
+ const char **keywords = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
+ const char **values = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
keywords[0] = "host";
values[0] = PQhost(AH->connection);
do
{
#define PARAMS_ARRAY_SIZE 7
- const char **keywords = malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
- const char **values = malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
-
- if (!keywords || !values)
- die_horribly(AH, modulename, "out of memory\n");
+ const char **keywords = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
+ const char **values = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
keywords[0] = "host";
values[0] = pghost;
ExecuteSqlCommand(AH, buf, "could not execute query");
else
{
- char *str = (char *) malloc(bufLen + 1);
+ char *str = (char *) pg_malloc(bufLen + 1);
- if (!str)
- die_horribly(AH, modulename, "out of memory\n");
memcpy(str, buf, bufLen);
str[bufLen] = '\0';
ExecuteSqlCommand(AH, str, "could not execute query");
*/
#include "compress_io.h"
+#include "common.h"
#include <dirent.h>
#include <sys/stat.h>
AH->DeClonePtr = NULL;
/* Set up our private context */
- ctx = (lclContext *) calloc(1, sizeof(lclContext));
- if (ctx == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ ctx = (lclContext *) pg_calloc(1, sizeof(lclContext));
AH->formatData = (void *) ctx;
ctx->dataFH = NULL;
/* Initialize LO buffering */
AH->lo_buf_size = LOBBUFSIZE;
- AH->lo_buf = (void *) malloc(LOBBUFSIZE);
- if (AH->lo_buf == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
/*
* Now open the TOC file
lclTocEntry *tctx;
char fn[MAXPGPATH];
- tctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
- if (!tctx)
- die_horribly(AH, modulename, "out of memory\n");
+ tctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
if (te->dataDumper)
{
snprintf(fn, MAXPGPATH, "%d.dat", te->dumpId);
- tctx->filename = strdup(fn);
+ tctx->filename = pg_strdup(fn);
}
else if (strcmp(te->desc, "BLOBS") == 0)
- tctx->filename = strdup("blobs.toc");
+ tctx->filename = pg_strdup("blobs.toc");
else
tctx->filename = NULL;
if (tctx == NULL)
{
- tctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
- if (!tctx)
- die_horribly(AH, modulename, "out of memory\n");
+ tctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
te->formatData = (void *) tctx;
}
die_horribly(AH, modulename, "could not open input file \"%s\": %s\n",
filename, strerror(errno));
- buf = malloc(ZLIB_OUT_SIZE);
- if (buf == NULL)
- die_horribly(NULL, modulename, "out of memory\n");
+ buf = pg_malloc(ZLIB_OUT_SIZE);
buflen = ZLIB_OUT_SIZE;
while ((cnt = cfread(buf, buflen, cfp)))
*/
#include "pg_backup_archiver.h"
+#include "common.h"
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te);
static void _StartData(ArchiveHandle *AH, TocEntry *te);
/*
* Set up some special context used in compressing data.
*/
- ctx = (lclContext *) calloc(1, sizeof(lclContext));
+ ctx = (lclContext *) pg_calloc(1, sizeof(lclContext));
AH->formatData = (void *) ctx;
ctx->filePos = 0;
/* Initialize LO buffering */
AH->lo_buf_size = LOBBUFSIZE;
- AH->lo_buf = (void *) malloc(LOBBUFSIZE);
- if (AH->lo_buf == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
/*
* Now open the TOC file
lclTocEntry *ctx;
char fn[K_STD_BUF_SIZE];
- ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
+ ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
if (te->dataDumper)
{
#ifdef HAVE_LIBZ
#else
sprintf(fn, "%d.dat", te->dumpId);
#endif
- ctx->filename = strdup(fn);
+ ctx->filename = pg_strdup(fn);
}
else
{
if (ctx == NULL)
{
- ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
+ ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
te->formatData = (void *) ctx;
}
*/
#include "pg_backup_archiver.h"
+#include "common.h"
#include "dumputils.h"
#include <unistd.h> /* for dup */
/* Initialize LO buffering */
AH->lo_buf_size = LOBBUFSIZE;
- AH->lo_buf = (void *) malloc(LOBBUFSIZE);
- if (AH->lo_buf == NULL)
- die_horribly(AH, NULL, "out of memory\n");
+ AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
/*
* Now prevent reading...
#include "pg_backup.h"
#include "pg_backup_archiver.h"
#include "pg_backup_tar.h"
+#include "common.h"
#include <sys/stat.h>
#include <ctype.h>
/*
* Set up some special context used in compressing data.
*/
- ctx = (lclContext *) calloc(1, sizeof(lclContext));
+ ctx = (lclContext *) pg_calloc(1, sizeof(lclContext));
AH->formatData = (void *) ctx;
ctx->filePos = 0;
ctx->isSpecialScript = 0;
/* Initialize LO buffering */
AH->lo_buf_size = LOBBUFSIZE;
- AH->lo_buf = (void *) malloc(LOBBUFSIZE);
- if (AH->lo_buf == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
/*
* Now open the tar file, and load the TOC if we're in read mode.
lclTocEntry *ctx;
char fn[K_STD_BUF_SIZE];
- ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
+ ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
if (te->dataDumper != NULL)
{
#ifdef HAVE_LIBZ
#else
sprintf(fn, "%d.dat", te->dumpId);
#endif
- ctx->filename = strdup(fn);
+ ctx->filename = pg_strdup(fn);
}
else
{
if (ctx == NULL)
{
- ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
+ ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
te->formatData = (void *) ctx;
}
}
else
{
- tm = calloc(1, sizeof(TAR_MEMBER));
+ tm = pg_calloc(1, sizeof(TAR_MEMBER));
#ifndef WIN32
tm->tmpFH = tmpfile();
#endif
tm->AH = AH;
- tm->targetFile = strdup(filename);
+ tm->targetFile = pg_strdup(filename);
}
tm->mode = mode;
ahprintf(AH, "\\.\n");
/* Get a copy of the COPY statement and clean it up */
- tmpCopy = strdup(te->copyStmt);
+ tmpCopy = pg_strdup(te->copyStmt);
for (i = 0; i < strlen(tmpCopy); i++)
tmpCopy[i] = pg_tolower((unsigned char) tmpCopy[i]);
if (p != NULL)
free(p);
bSize *= 2;
- p = (char *) malloc(bSize);
- if (p == NULL)
- die_horribly(AH, modulename, "out of memory\n");
+ p = (char *) pg_malloc(bSize);
va_start(ap, fmt);
cnt = vsnprintf(p, bSize, fmt, ap);
va_end(ap);
_tarPositionTo(ArchiveHandle *AH, const char *filename)
{
lclContext *ctx = (lclContext *) AH->formatData;
- TAR_MEMBER *th = calloc(1, sizeof(TAR_MEMBER));
+ TAR_MEMBER *th = pg_calloc(1, sizeof(TAR_MEMBER));
char c;
char header[512];
size_t i,
tag, sum, chk, buf);
}
- th->targetFile = strdup(tag);
+ th->targetFile = pg_strdup(tag);
th->fileLen = len;
return 1;
#include "libpq/libpq-fs.h"
#include "pg_backup_archiver.h"
+#include "common.h"
#include "dumputils.h"
extern char *optarg;
break;
case 'S': /* Username for superuser in plain text output */
- outputSuperuser = strdup(optarg);
+ outputSuperuser = pg_strdup(optarg);
break;
case 't': /* include table(s) */
{
TableDataInfo *tdinfo;
- tdinfo = (TableDataInfo *) malloc(sizeof(TableDataInfo));
+ tdinfo = (TableDataInfo *) pg_malloc(sizeof(TableDataInfo));
tdinfo->dobj.objType = DO_TABLE_DATA;
/*
* Each large object has its own BLOB archive entry.
*/
- binfo = (BlobInfo *) malloc(ntups * sizeof(BlobInfo));
+ binfo = (BlobInfo *) pg_malloc(ntups * sizeof(BlobInfo));
for (i = 0; i < ntups; i++)
{
binfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, 0));
AssignDumpId(&binfo[i].dobj);
- binfo[i].dobj.name = strdup(PQgetvalue(res, i, 0));
+ binfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, 0));
if (!PQgetisnull(res, i, 1))
- binfo[i].rolname = strdup(PQgetvalue(res, i, 1));
+ binfo[i].rolname = pg_strdup(PQgetvalue(res, i, 1));
else
binfo[i].rolname = "";
if (!PQgetisnull(res, i, 2))
- binfo[i].blobacl = strdup(PQgetvalue(res, i, 2));
+ binfo[i].blobacl = pg_strdup(PQgetvalue(res, i, 2));
else
binfo[i].blobacl = NULL;
}
* If we have any large objects, a "BLOBS" archive entry is needed.
* This is just a placeholder for sorting; it carries no data now.
*/
- bdata = (DumpableObject *) malloc(sizeof(DumpableObject));
+ bdata = (DumpableObject *) pg_malloc(sizeof(DumpableObject));
bdata->objType = DO_BLOB_DATA;
bdata->catId = nilCatalogId;
AssignDumpId(bdata);
- bdata->name = strdup("BLOBS");
+ bdata->name = pg_strdup("BLOBS");
}
PQclear(res);
*/
if (g_fout->remoteVersion < 70300)
{
- nsinfo = (NamespaceInfo *) malloc(2 * sizeof(NamespaceInfo));
+ nsinfo = (NamespaceInfo *) pg_malloc(2 * sizeof(NamespaceInfo));
nsinfo[0].dobj.objType = DO_NAMESPACE;
nsinfo[0].dobj.catId.tableoid = 0;
nsinfo[0].dobj.catId.oid = 0;
AssignDumpId(&nsinfo[0].dobj);
- nsinfo[0].dobj.name = strdup("public");
- nsinfo[0].rolname = strdup("");
- nsinfo[0].nspacl = strdup("");
+ nsinfo[0].dobj.name = pg_strdup("public");
+ nsinfo[0].rolname = pg_strdup("");
+ nsinfo[0].nspacl = pg_strdup("");
selectDumpableNamespace(&nsinfo[0]);
nsinfo[1].dobj.catId.tableoid = 0;
nsinfo[1].dobj.catId.oid = 1;
AssignDumpId(&nsinfo[1].dobj);
- nsinfo[1].dobj.name = strdup("pg_catalog");
- nsinfo[1].rolname = strdup("");
- nsinfo[1].nspacl = strdup("");
+ nsinfo[1].dobj.name = pg_strdup("pg_catalog");
+ nsinfo[1].rolname = pg_strdup("");
+ nsinfo[1].nspacl = pg_strdup("");
selectDumpableNamespace(&nsinfo[1]);
ntups = PQntuples(res);
- nsinfo = (NamespaceInfo *) malloc(ntups * sizeof(NamespaceInfo));
+ nsinfo = (NamespaceInfo *) pg_malloc(ntups * sizeof(NamespaceInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
nsinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
nsinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&nsinfo[i].dobj);
- nsinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_nspname));
- nsinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
- nsinfo[i].nspacl = strdup(PQgetvalue(res, i, i_nspacl));
+ nsinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_nspname));
+ nsinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
+ nsinfo[i].nspacl = pg_strdup(PQgetvalue(res, i, i_nspacl));
/* Decide whether to dump this namespace */
selectDumpableNamespace(&nsinfo[i]);
ntups = PQntuples(res);
- extinfo = (ExtensionInfo *) malloc(ntups * sizeof(ExtensionInfo));
+ extinfo = (ExtensionInfo *) pg_malloc(ntups * sizeof(ExtensionInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
extinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
extinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&extinfo[i].dobj);
- extinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_extname));
- extinfo[i].namespace = strdup(PQgetvalue(res, i, i_nspname));
+ extinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_extname));
+ extinfo[i].namespace = pg_strdup(PQgetvalue(res, i, i_nspname));
extinfo[i].relocatable = *(PQgetvalue(res, i, i_extrelocatable)) == 't';
- extinfo[i].extversion = strdup(PQgetvalue(res, i, i_extversion));
- extinfo[i].extconfig = strdup(PQgetvalue(res, i, i_extconfig));
- extinfo[i].extcondition = strdup(PQgetvalue(res, i, i_extcondition));
+ extinfo[i].extversion = pg_strdup(PQgetvalue(res, i, i_extversion));
+ extinfo[i].extconfig = pg_strdup(PQgetvalue(res, i, i_extconfig));
+ extinfo[i].extcondition = pg_strdup(PQgetvalue(res, i, i_extcondition));
/* Decide whether we want to dump it */
selectDumpableExtension(&(extinfo[i]));
ntups = PQntuples(res);
- tyinfo = (TypeInfo *) malloc(ntups * sizeof(TypeInfo));
+ tyinfo = (TypeInfo *) pg_malloc(ntups * sizeof(TypeInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
tyinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
tyinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&tyinfo[i].dobj);
- tyinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_typname));
+ tyinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_typname));
tyinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_typnamespace)),
tyinfo[i].dobj.catId.oid);
- tyinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ tyinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
tyinfo[i].typelem = atooid(PQgetvalue(res, i, i_typelem));
tyinfo[i].typrelid = atooid(PQgetvalue(res, i, i_typrelid));
tyinfo[i].typrelkind = *PQgetvalue(res, i, i_typrelkind);
if (tyinfo[i].dobj.dump && (tyinfo[i].typtype == TYPTYPE_BASE ||
tyinfo[i].typtype == TYPTYPE_RANGE))
{
- stinfo = (ShellTypeInfo *) malloc(sizeof(ShellTypeInfo));
+ stinfo = (ShellTypeInfo *) pg_malloc(sizeof(ShellTypeInfo));
stinfo->dobj.objType = DO_SHELL_TYPE;
stinfo->dobj.catId = nilCatalogId;
AssignDumpId(&stinfo->dobj);
- stinfo->dobj.name = strdup(tyinfo[i].dobj.name);
+ stinfo->dobj.name = pg_strdup(tyinfo[i].dobj.name);
stinfo->dobj.namespace = tyinfo[i].dobj.namespace;
stinfo->baseType = &(tyinfo[i]);
tyinfo[i].shellType = stinfo;
ntups = PQntuples(res);
*numOprs = ntups;
- oprinfo = (OprInfo *) malloc(ntups * sizeof(OprInfo));
+ oprinfo = (OprInfo *) pg_malloc(ntups * sizeof(OprInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
oprinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
oprinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&oprinfo[i].dobj);
- oprinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_oprname));
+ oprinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_oprname));
oprinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_oprnamespace)),
oprinfo[i].dobj.catId.oid);
- oprinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ oprinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
oprinfo[i].oprcode = atooid(PQgetvalue(res, i, i_oprcode));
/* Decide whether we want to dump it */
ntups = PQntuples(res);
*numCollations = ntups;
- collinfo = (CollInfo *) malloc(ntups * sizeof(CollInfo));
+ collinfo = (CollInfo *) pg_malloc(ntups * sizeof(CollInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
collinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
collinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&collinfo[i].dobj);
- collinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_collname));
+ collinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_collname));
collinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_collnamespace)),
collinfo[i].dobj.catId.oid);
- collinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ collinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
/* Decide whether we want to dump it */
selectDumpableObject(&(collinfo[i].dobj));
ntups = PQntuples(res);
*numConversions = ntups;
- convinfo = (ConvInfo *) malloc(ntups * sizeof(ConvInfo));
+ convinfo = (ConvInfo *) pg_malloc(ntups * sizeof(ConvInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
convinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
convinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&convinfo[i].dobj);
- convinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_conname));
+ convinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_conname));
convinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_connamespace)),
convinfo[i].dobj.catId.oid);
- convinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ convinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
/* Decide whether we want to dump it */
selectDumpableObject(&(convinfo[i].dobj));
ntups = PQntuples(res);
*numOpclasses = ntups;
- opcinfo = (OpclassInfo *) malloc(ntups * sizeof(OpclassInfo));
+ opcinfo = (OpclassInfo *) pg_malloc(ntups * sizeof(OpclassInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
opcinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
opcinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&opcinfo[i].dobj);
- opcinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_opcname));
+ opcinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_opcname));
opcinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_opcnamespace)),
opcinfo[i].dobj.catId.oid);
- opcinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ opcinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
/* Decide whether we want to dump it */
selectDumpableObject(&(opcinfo[i].dobj));
ntups = PQntuples(res);
*numOpfamilies = ntups;
- opfinfo = (OpfamilyInfo *) malloc(ntups * sizeof(OpfamilyInfo));
+ opfinfo = (OpfamilyInfo *) pg_malloc(ntups * sizeof(OpfamilyInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
opfinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
opfinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&opfinfo[i].dobj);
- opfinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_opfname));
+ opfinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_opfname));
opfinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_opfnamespace)),
opfinfo[i].dobj.catId.oid);
- opfinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ opfinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
/* Decide whether we want to dump it */
selectDumpableObject(&(opfinfo[i].dobj));
ntups = PQntuples(res);
*numAggs = ntups;
- agginfo = (AggInfo *) malloc(ntups * sizeof(AggInfo));
+ agginfo = (AggInfo *) pg_malloc(ntups * sizeof(AggInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
agginfo[i].aggfn.dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
agginfo[i].aggfn.dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&agginfo[i].aggfn.dobj);
- agginfo[i].aggfn.dobj.name = strdup(PQgetvalue(res, i, i_aggname));
+ agginfo[i].aggfn.dobj.name = pg_strdup(PQgetvalue(res, i, i_aggname));
agginfo[i].aggfn.dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_aggnamespace)),
agginfo[i].aggfn.dobj.catId.oid);
- agginfo[i].aggfn.rolname = strdup(PQgetvalue(res, i, i_rolname));
+ agginfo[i].aggfn.rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
if (strlen(agginfo[i].aggfn.rolname) == 0)
write_msg(NULL, "WARNING: owner of aggregate function \"%s\" appears to be invalid\n",
agginfo[i].aggfn.dobj.name);
agginfo[i].aggfn.lang = InvalidOid; /* not currently interesting */
agginfo[i].aggfn.prorettype = InvalidOid; /* not saved */
- agginfo[i].aggfn.proacl = strdup(PQgetvalue(res, i, i_aggacl));
+ agginfo[i].aggfn.proacl = pg_strdup(PQgetvalue(res, i, i_aggacl));
agginfo[i].aggfn.nargs = atoi(PQgetvalue(res, i, i_pronargs));
if (agginfo[i].aggfn.nargs == 0)
agginfo[i].aggfn.argtypes = NULL;
else
{
- agginfo[i].aggfn.argtypes = (Oid *) malloc(agginfo[i].aggfn.nargs * sizeof(Oid));
+ agginfo[i].aggfn.argtypes = (Oid *) pg_malloc(agginfo[i].aggfn.nargs * sizeof(Oid));
if (g_fout->remoteVersion >= 70300)
parseOidArray(PQgetvalue(res, i, i_proargtypes),
agginfo[i].aggfn.argtypes,
*numFuncs = ntups;
- finfo = (FuncInfo *) calloc(ntups, sizeof(FuncInfo));
+ finfo = (FuncInfo *) pg_calloc(ntups, sizeof(FuncInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
finfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
finfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&finfo[i].dobj);
- finfo[i].dobj.name = strdup(PQgetvalue(res, i, i_proname));
+ finfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_proname));
finfo[i].dobj.namespace =
findNamespace(atooid(PQgetvalue(res, i, i_pronamespace)),
finfo[i].dobj.catId.oid);
- finfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ finfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
finfo[i].lang = atooid(PQgetvalue(res, i, i_prolang));
finfo[i].prorettype = atooid(PQgetvalue(res, i, i_prorettype));
- finfo[i].proacl = strdup(PQgetvalue(res, i, i_proacl));
+ finfo[i].proacl = pg_strdup(PQgetvalue(res, i, i_proacl));
finfo[i].nargs = atoi(PQgetvalue(res, i, i_pronargs));
if (finfo[i].nargs == 0)
finfo[i].argtypes = NULL;
else
{
- finfo[i].argtypes = (Oid *) malloc(finfo[i].nargs * sizeof(Oid));
+ finfo[i].argtypes = (Oid *) pg_malloc(finfo[i].nargs * sizeof(Oid));
parseOidArray(PQgetvalue(res, i, i_proargtypes),
finfo[i].argtypes, finfo[i].nargs);
}
* only one, because we don't yet know which tables might be inheritance
* ancestors of the target table.
*/
- tblinfo = (TableInfo *) calloc(ntups, sizeof(TableInfo));
+ tblinfo = (TableInfo *) pg_calloc(ntups, sizeof(TableInfo));
i_reltableoid = PQfnumber(res, "tableoid");
i_reloid = PQfnumber(res, "oid");
tblinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_reltableoid));
tblinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_reloid));
AssignDumpId(&tblinfo[i].dobj);
- tblinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_relname));
+ tblinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_relname));
tblinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_relnamespace)),
tblinfo[i].dobj.catId.oid);
- tblinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
- tblinfo[i].relacl = strdup(PQgetvalue(res, i, i_relacl));
+ tblinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
+ tblinfo[i].relacl = pg_strdup(PQgetvalue(res, i, i_relacl));
tblinfo[i].relkind = *(PQgetvalue(res, i, i_relkind));
tblinfo[i].relpersistence = *(PQgetvalue(res, i, i_relpersistence));
tblinfo[i].hasindex = (strcmp(PQgetvalue(res, i, i_relhasindex), "t") == 0);
if (PQgetisnull(res, i, i_reloftype))
tblinfo[i].reloftype = NULL;
else
- tblinfo[i].reloftype = strdup(PQgetvalue(res, i, i_reloftype));
+ tblinfo[i].reloftype = pg_strdup(PQgetvalue(res, i, i_reloftype));
tblinfo[i].ncheck = atoi(PQgetvalue(res, i, i_relchecks));
if (PQgetisnull(res, i, i_owning_tab))
{
tblinfo[i].owning_tab = atooid(PQgetvalue(res, i, i_owning_tab));
tblinfo[i].owning_col = atoi(PQgetvalue(res, i, i_owning_col));
}
- tblinfo[i].reltablespace = strdup(PQgetvalue(res, i, i_reltablespace));
- tblinfo[i].reloptions = strdup(PQgetvalue(res, i, i_reloptions));
- tblinfo[i].toast_reloptions = strdup(PQgetvalue(res, i, i_toastreloptions));
+ tblinfo[i].reltablespace = pg_strdup(PQgetvalue(res, i, i_reltablespace));
+ tblinfo[i].reloptions = pg_strdup(PQgetvalue(res, i, i_reloptions));
+ tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
/* other fields were zeroed above */
*numInherits = ntups;
- inhinfo = (InhInfo *) malloc(ntups * sizeof(InhInfo));
+ inhinfo = (InhInfo *) pg_malloc(ntups * sizeof(InhInfo));
i_inhrelid = PQfnumber(res, "inhrelid");
i_inhparent = PQfnumber(res, "inhparent");
i_tablespace = PQfnumber(res, "tablespace");
i_options = PQfnumber(res, "options");
- indxinfo = (IndxInfo *) malloc(ntups * sizeof(IndxInfo));
- constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));
+ indxinfo = (IndxInfo *) pg_malloc(ntups * sizeof(IndxInfo));
+ constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));
for (j = 0; j < ntups; j++)
{
indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
AssignDumpId(&indxinfo[j].dobj);
- indxinfo[j].dobj.name = strdup(PQgetvalue(res, j, i_indexname));
+ indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
indxinfo[j].indextable = tbinfo;
- indxinfo[j].indexdef = strdup(PQgetvalue(res, j, i_indexdef));
+ indxinfo[j].indexdef = pg_strdup(PQgetvalue(res, j, i_indexdef));
indxinfo[j].indnkeys = atoi(PQgetvalue(res, j, i_indnkeys));
- indxinfo[j].tablespace = strdup(PQgetvalue(res, j, i_tablespace));
- indxinfo[j].options = strdup(PQgetvalue(res, j, i_options));
+ indxinfo[j].tablespace = pg_strdup(PQgetvalue(res, j, i_tablespace));
+ indxinfo[j].options = pg_strdup(PQgetvalue(res, j, i_options));
/*
* In pre-7.4 releases, indkeys may contain more entries than
* have to allocate enough space to keep parseOidArray from
* complaining.
*/
- indxinfo[j].indkeys = (Oid *) malloc(INDEX_MAX_KEYS * sizeof(Oid));
+ indxinfo[j].indkeys = (Oid *) pg_malloc(INDEX_MAX_KEYS * sizeof(Oid));
parseOidArray(PQgetvalue(res, j, i_indkey),
indxinfo[j].indkeys, INDEX_MAX_KEYS);
indxinfo[j].indisclustered = (PQgetvalue(res, j, i_indisclustered)[0] == 't');
constrinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid));
constrinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid));
AssignDumpId(&constrinfo[j].dobj);
- constrinfo[j].dobj.name = strdup(PQgetvalue(res, j, i_conname));
+ constrinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
constrinfo[j].dobj.namespace = tbinfo->dobj.namespace;
constrinfo[j].contable = tbinfo;
constrinfo[j].condomain = NULL;
constrinfo[j].contype = contype;
if (contype == 'x')
- constrinfo[j].condef = strdup(PQgetvalue(res, j, i_condef));
+ constrinfo[j].condef = pg_strdup(PQgetvalue(res, j, i_condef));
else
constrinfo[j].condef = NULL;
constrinfo[j].confrelid = InvalidOid;
i_confrelid = PQfnumber(res, "confrelid");
i_condef = PQfnumber(res, "condef");
- constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));
+ constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));
for (j = 0; j < ntups; j++)
{
constrinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid));
constrinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid));
AssignDumpId(&constrinfo[j].dobj);
- constrinfo[j].dobj.name = strdup(PQgetvalue(res, j, i_conname));
+ constrinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
constrinfo[j].dobj.namespace = tbinfo->dobj.namespace;
constrinfo[j].contable = tbinfo;
constrinfo[j].condomain = NULL;
constrinfo[j].contype = 'f';
- constrinfo[j].condef = strdup(PQgetvalue(res, j, i_condef));
+ constrinfo[j].condef = pg_strdup(PQgetvalue(res, j, i_condef));
constrinfo[j].confrelid = atooid(PQgetvalue(res, j, i_confrelid));
constrinfo[j].conindex = 0;
constrinfo[j].condeferrable = false;
i_conname = PQfnumber(res, "conname");
i_consrc = PQfnumber(res, "consrc");
- constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));
+ constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));
tyinfo->nDomChecks = ntups;
tyinfo->domChecks = constrinfo;
constrinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
constrinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&constrinfo[i].dobj);
- constrinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_conname));
+ constrinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_conname));
constrinfo[i].dobj.namespace = tyinfo->dobj.namespace;
constrinfo[i].contable = NULL;
constrinfo[i].condomain = tyinfo;
constrinfo[i].contype = 'c';
- constrinfo[i].condef = strdup(PQgetvalue(res, i, i_consrc));
+ constrinfo[i].condef = pg_strdup(PQgetvalue(res, i, i_consrc));
constrinfo[i].confrelid = InvalidOid;
constrinfo[i].conindex = 0;
constrinfo[i].condeferrable = false;
*numRules = ntups;
- ruleinfo = (RuleInfo *) malloc(ntups * sizeof(RuleInfo));
+ ruleinfo = (RuleInfo *) pg_malloc(ntups * sizeof(RuleInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
ruleinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
ruleinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&ruleinfo[i].dobj);
- ruleinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_rulename));
+ ruleinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_rulename));
ruletableoid = atooid(PQgetvalue(res, i, i_ruletable));
ruleinfo[i].ruletable = findTableByOid(ruletableoid);
if (ruleinfo[i].ruletable == NULL)
i_tginitdeferred = PQfnumber(res, "tginitdeferred");
i_tgdef = PQfnumber(res, "tgdef");
- tginfo = (TriggerInfo *) malloc(ntups * sizeof(TriggerInfo));
+ tginfo = (TriggerInfo *) pg_malloc(ntups * sizeof(TriggerInfo));
for (j = 0; j < ntups; j++)
{
tginfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
tginfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
AssignDumpId(&tginfo[j].dobj);
- tginfo[j].dobj.name = strdup(PQgetvalue(res, j, i_tgname));
+ tginfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_tgname));
tginfo[j].dobj.namespace = tbinfo->dobj.namespace;
tginfo[j].tgtable = tbinfo;
tginfo[j].tgenabled = *(PQgetvalue(res, j, i_tgenabled));
if (i_tgdef >= 0)
{
- tginfo[j].tgdef = strdup(PQgetvalue(res, j, i_tgdef));
+ tginfo[j].tgdef = pg_strdup(PQgetvalue(res, j, i_tgdef));
/* remaining fields are not valid if we have tgdef */
tginfo[j].tgfname = NULL;
{
tginfo[j].tgdef = NULL;
- tginfo[j].tgfname = strdup(PQgetvalue(res, j, i_tgfname));
+ tginfo[j].tgfname = pg_strdup(PQgetvalue(res, j, i_tgfname));
tginfo[j].tgtype = atoi(PQgetvalue(res, j, i_tgtype));
tginfo[j].tgnargs = atoi(PQgetvalue(res, j, i_tgnargs));
- tginfo[j].tgargs = strdup(PQgetvalue(res, j, i_tgargs));
+ tginfo[j].tgargs = pg_strdup(PQgetvalue(res, j, i_tgargs));
tginfo[j].tgisconstraint = *(PQgetvalue(res, j, i_tgisconstraint)) == 't';
tginfo[j].tgdeferrable = *(PQgetvalue(res, j, i_tgdeferrable)) == 't';
tginfo[j].tginitdeferred = *(PQgetvalue(res, j, i_tginitdeferred)) == 't';
if (tginfo[j].tgisconstraint)
{
- tginfo[j].tgconstrname = strdup(PQgetvalue(res, j, i_tgconstrname));
+ tginfo[j].tgconstrname = pg_strdup(PQgetvalue(res, j, i_tgconstrname));
tginfo[j].tgconstrrelid = atooid(PQgetvalue(res, j, i_tgconstrrelid));
if (OidIsValid(tginfo[j].tgconstrrelid))
{
tginfo[j].tgconstrrelid);
exit_nicely();
}
- tginfo[j].tgconstrrelname = strdup(PQgetvalue(res, j, i_tgconstrrelname));
+ tginfo[j].tgconstrrelname = pg_strdup(PQgetvalue(res, j, i_tgconstrrelname));
}
else
tginfo[j].tgconstrrelname = NULL;
*numProcLangs = ntups;
- planginfo = (ProcLangInfo *) malloc(ntups * sizeof(ProcLangInfo));
+ planginfo = (ProcLangInfo *) pg_malloc(ntups * sizeof(ProcLangInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
planginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&planginfo[i].dobj);
- planginfo[i].dobj.name = strdup(PQgetvalue(res, i, i_lanname));
+ planginfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_lanname));
planginfo[i].lanpltrusted = *(PQgetvalue(res, i, i_lanpltrusted)) == 't';
planginfo[i].lanplcallfoid = atooid(PQgetvalue(res, i, i_lanplcallfoid));
if (i_laninline >= 0)
else
planginfo[i].lanvalidator = InvalidOid;
if (i_lanacl >= 0)
- planginfo[i].lanacl = strdup(PQgetvalue(res, i, i_lanacl));
+ planginfo[i].lanacl = pg_strdup(PQgetvalue(res, i, i_lanacl));
else
- planginfo[i].lanacl = strdup("{=U}");
+ planginfo[i].lanacl = pg_strdup("{=U}");
if (i_lanowner >= 0)
- planginfo[i].lanowner = strdup(PQgetvalue(res, i, i_lanowner));
+ planginfo[i].lanowner = pg_strdup(PQgetvalue(res, i, i_lanowner));
else
- planginfo[i].lanowner = strdup("");
+ planginfo[i].lanowner = pg_strdup("");
if (g_fout->remoteVersion < 70300)
{
*numCasts = ntups;
- castinfo = (CastInfo *) malloc(ntups * sizeof(CastInfo));
+ castinfo = (CastInfo *) pg_malloc(ntups * sizeof(CastInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
i_attfdwoptions = PQfnumber(res, "attfdwoptions");
tbinfo->numatts = ntups;
- tbinfo->attnames = (char **) malloc(ntups * sizeof(char *));
- tbinfo->atttypnames = (char **) malloc(ntups * sizeof(char *));
- tbinfo->atttypmod = (int *) malloc(ntups * sizeof(int));
- tbinfo->attstattarget = (int *) malloc(ntups * sizeof(int));
- tbinfo->attstorage = (char *) malloc(ntups * sizeof(char));
- tbinfo->typstorage = (char *) malloc(ntups * sizeof(char));
- tbinfo->attisdropped = (bool *) malloc(ntups * sizeof(bool));
- tbinfo->attlen = (int *) malloc(ntups * sizeof(int));
- tbinfo->attalign = (char *) malloc(ntups * sizeof(char));
- tbinfo->attislocal = (bool *) malloc(ntups * sizeof(bool));
- tbinfo->notnull = (bool *) malloc(ntups * sizeof(bool));
- tbinfo->attrdefs = (AttrDefInfo **) malloc(ntups * sizeof(AttrDefInfo *));
- tbinfo->attoptions = (char **) malloc(ntups * sizeof(char *));
- tbinfo->attcollation = (Oid *) malloc(ntups * sizeof(Oid));
- tbinfo->attfdwoptions = (char **) malloc(ntups * sizeof(char *));
- tbinfo->inhAttrs = (bool *) malloc(ntups * sizeof(bool));
- tbinfo->inhAttrDef = (bool *) malloc(ntups * sizeof(bool));
- tbinfo->inhNotNull = (bool *) malloc(ntups * sizeof(bool));
+ tbinfo->attnames = (char **) pg_malloc(ntups * sizeof(char *));
+ tbinfo->atttypnames = (char **) pg_malloc(ntups * sizeof(char *));
+ tbinfo->atttypmod = (int *) pg_malloc(ntups * sizeof(int));
+ tbinfo->attstattarget = (int *) pg_malloc(ntups * sizeof(int));
+ tbinfo->attstorage = (char *) pg_malloc(ntups * sizeof(char));
+ tbinfo->typstorage = (char *) pg_malloc(ntups * sizeof(char));
+ tbinfo->attisdropped = (bool *) pg_malloc(ntups * sizeof(bool));
+ tbinfo->attlen = (int *) pg_malloc(ntups * sizeof(int));
+ tbinfo->attalign = (char *) pg_malloc(ntups * sizeof(char));
+ tbinfo->attislocal = (bool *) pg_malloc(ntups * sizeof(bool));
+ tbinfo->notnull = (bool *) pg_malloc(ntups * sizeof(bool));
+ tbinfo->attrdefs = (AttrDefInfo **) pg_malloc(ntups * sizeof(AttrDefInfo *));
+ tbinfo->attoptions = (char **) pg_malloc(ntups * sizeof(char *));
+ tbinfo->attcollation = (Oid *) pg_malloc(ntups * sizeof(Oid));
+ tbinfo->attfdwoptions = (char **) pg_malloc(ntups * sizeof(char *));
+ tbinfo->inhAttrs = (bool *) pg_malloc(ntups * sizeof(bool));
+ tbinfo->inhAttrDef = (bool *) pg_malloc(ntups * sizeof(bool));
+ tbinfo->inhNotNull = (bool *) pg_malloc(ntups * sizeof(bool));
hasdefaults = false;
for (j = 0; j < ntups; j++)
tbinfo->dobj.name);
exit_nicely();
}
- tbinfo->attnames[j] = strdup(PQgetvalue(res, j, i_attname));
- tbinfo->atttypnames[j] = strdup(PQgetvalue(res, j, i_atttypname));
+ tbinfo->attnames[j] = pg_strdup(PQgetvalue(res, j, i_attname));
+ tbinfo->atttypnames[j] = pg_strdup(PQgetvalue(res, j, i_atttypname));
tbinfo->atttypmod[j] = atoi(PQgetvalue(res, j, i_atttypmod));
tbinfo->attstattarget[j] = atoi(PQgetvalue(res, j, i_attstattarget));
tbinfo->attstorage[j] = *(PQgetvalue(res, j, i_attstorage));
tbinfo->attalign[j] = *(PQgetvalue(res, j, i_attalign));
tbinfo->attislocal[j] = (PQgetvalue(res, j, i_attislocal)[0] == 't');
tbinfo->notnull[j] = (PQgetvalue(res, j, i_attnotnull)[0] == 't');
- tbinfo->attoptions[j] = strdup(PQgetvalue(res, j, i_attoptions));
+ tbinfo->attoptions[j] = pg_strdup(PQgetvalue(res, j, i_attoptions));
tbinfo->attcollation[j] = atooid(PQgetvalue(res, j, i_attcollation));
- tbinfo->attfdwoptions[j] = strdup(PQgetvalue(res, j, i_attfdwoptions));
+ tbinfo->attfdwoptions[j] = pg_strdup(PQgetvalue(res, j, i_attfdwoptions));
tbinfo->attrdefs[j] = NULL; /* fix below */
if (PQgetvalue(res, j, i_atthasdef)[0] == 't')
hasdefaults = true;
check_sql_result(res, g_conn, q->data, PGRES_TUPLES_OK);
numDefaults = PQntuples(res);
- attrdefs = (AttrDefInfo *) malloc(numDefaults * sizeof(AttrDefInfo));
+ attrdefs = (AttrDefInfo *) pg_malloc(numDefaults * sizeof(AttrDefInfo));
for (j = 0; j < numDefaults; j++)
{
AssignDumpId(&attrdefs[j].dobj);
attrdefs[j].adtable = tbinfo;
attrdefs[j].adnum = adnum = atoi(PQgetvalue(res, j, 2));
- attrdefs[j].adef_expr = strdup(PQgetvalue(res, j, 3));
+ attrdefs[j].adef_expr = pg_strdup(PQgetvalue(res, j, 3));
- attrdefs[j].dobj.name = strdup(tbinfo->dobj.name);
+ attrdefs[j].dobj.name = pg_strdup(tbinfo->dobj.name);
attrdefs[j].dobj.namespace = tbinfo->dobj.namespace;
attrdefs[j].dobj.dump = tbinfo->dobj.dump;
exit_nicely();
}
- constrs = (ConstraintInfo *) malloc(numConstrs * sizeof(ConstraintInfo));
+ constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(ConstraintInfo));
tbinfo->checkexprs = constrs;
for (j = 0; j < numConstrs; j++)
constrs[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, 0));
constrs[j].dobj.catId.oid = atooid(PQgetvalue(res, j, 1));
AssignDumpId(&constrs[j].dobj);
- constrs[j].dobj.name = strdup(PQgetvalue(res, j, 2));
+ constrs[j].dobj.name = pg_strdup(PQgetvalue(res, j, 2));
constrs[j].dobj.namespace = tbinfo->dobj.namespace;
constrs[j].contable = tbinfo;
constrs[j].condomain = NULL;
constrs[j].contype = 'c';
- constrs[j].condef = strdup(PQgetvalue(res, j, 3));
+ constrs[j].condef = pg_strdup(PQgetvalue(res, j, 3));
constrs[j].confrelid = InvalidOid;
constrs[j].conindex = 0;
constrs[j].condeferrable = false;
ntups = PQntuples(res);
*numTSParsers = ntups;
- prsinfo = (TSParserInfo *) malloc(ntups * sizeof(TSParserInfo));
+ prsinfo = (TSParserInfo *) pg_malloc(ntups * sizeof(TSParserInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
prsinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
prsinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&prsinfo[i].dobj);
- prsinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_prsname));
+ prsinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_prsname));
prsinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_prsnamespace)),
prsinfo[i].dobj.catId.oid);
prsinfo[i].prsstart = atooid(PQgetvalue(res, i, i_prsstart));
ntups = PQntuples(res);
*numTSDicts = ntups;
- dictinfo = (TSDictInfo *) malloc(ntups * sizeof(TSDictInfo));
+ dictinfo = (TSDictInfo *) pg_malloc(ntups * sizeof(TSDictInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
dictinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
dictinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&dictinfo[i].dobj);
- dictinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_dictname));
+ dictinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_dictname));
dictinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_dictnamespace)),
dictinfo[i].dobj.catId.oid);
- dictinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ dictinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
dictinfo[i].dicttemplate = atooid(PQgetvalue(res, i, i_dicttemplate));
if (PQgetisnull(res, i, i_dictinitoption))
dictinfo[i].dictinitoption = NULL;
else
- dictinfo[i].dictinitoption = strdup(PQgetvalue(res, i, i_dictinitoption));
+ dictinfo[i].dictinitoption = pg_strdup(PQgetvalue(res, i, i_dictinitoption));
/* Decide whether we want to dump it */
selectDumpableObject(&(dictinfo[i].dobj));
ntups = PQntuples(res);
*numTSTemplates = ntups;
- tmplinfo = (TSTemplateInfo *) malloc(ntups * sizeof(TSTemplateInfo));
+ tmplinfo = (TSTemplateInfo *) pg_malloc(ntups * sizeof(TSTemplateInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
tmplinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
tmplinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&tmplinfo[i].dobj);
- tmplinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_tmplname));
+ tmplinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_tmplname));
tmplinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_tmplnamespace)),
tmplinfo[i].dobj.catId.oid);
tmplinfo[i].tmplinit = atooid(PQgetvalue(res, i, i_tmplinit));
ntups = PQntuples(res);
*numTSConfigs = ntups;
- cfginfo = (TSConfigInfo *) malloc(ntups * sizeof(TSConfigInfo));
+ cfginfo = (TSConfigInfo *) pg_malloc(ntups * sizeof(TSConfigInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
cfginfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
cfginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&cfginfo[i].dobj);
- cfginfo[i].dobj.name = strdup(PQgetvalue(res, i, i_cfgname));
+ cfginfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_cfgname));
cfginfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_cfgnamespace)),
cfginfo[i].dobj.catId.oid);
- cfginfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ cfginfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
cfginfo[i].cfgparser = atooid(PQgetvalue(res, i, i_cfgparser));
/* Decide whether we want to dump it */
ntups = PQntuples(res);
*numForeignDataWrappers = ntups;
- fdwinfo = (FdwInfo *) malloc(ntups * sizeof(FdwInfo));
+ fdwinfo = (FdwInfo *) pg_malloc(ntups * sizeof(FdwInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
fdwinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
fdwinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&fdwinfo[i].dobj);
- fdwinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_fdwname));
+ fdwinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_fdwname));
fdwinfo[i].dobj.namespace = NULL;
- fdwinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
- fdwinfo[i].fdwhandler = strdup(PQgetvalue(res, i, i_fdwhandler));
- fdwinfo[i].fdwvalidator = strdup(PQgetvalue(res, i, i_fdwvalidator));
- fdwinfo[i].fdwoptions = strdup(PQgetvalue(res, i, i_fdwoptions));
- fdwinfo[i].fdwacl = strdup(PQgetvalue(res, i, i_fdwacl));
+ fdwinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
+ fdwinfo[i].fdwhandler = pg_strdup(PQgetvalue(res, i, i_fdwhandler));
+ fdwinfo[i].fdwvalidator = pg_strdup(PQgetvalue(res, i, i_fdwvalidator));
+ fdwinfo[i].fdwoptions = pg_strdup(PQgetvalue(res, i, i_fdwoptions));
+ fdwinfo[i].fdwacl = pg_strdup(PQgetvalue(res, i, i_fdwacl));
/* Decide whether we want to dump it */
selectDumpableObject(&(fdwinfo[i].dobj));
ntups = PQntuples(res);
*numForeignServers = ntups;
- srvinfo = (ForeignServerInfo *) malloc(ntups * sizeof(ForeignServerInfo));
+ srvinfo = (ForeignServerInfo *) pg_malloc(ntups * sizeof(ForeignServerInfo));
i_tableoid = PQfnumber(res, "tableoid");
i_oid = PQfnumber(res, "oid");
srvinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
srvinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&srvinfo[i].dobj);
- srvinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_srvname));
+ srvinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_srvname));
srvinfo[i].dobj.namespace = NULL;
- srvinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ srvinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
srvinfo[i].srvfdw = atooid(PQgetvalue(res, i, i_srvfdw));
- srvinfo[i].srvtype = strdup(PQgetvalue(res, i, i_srvtype));
- srvinfo[i].srvversion = strdup(PQgetvalue(res, i, i_srvversion));
- srvinfo[i].srvoptions = strdup(PQgetvalue(res, i, i_srvoptions));
- srvinfo[i].srvacl = strdup(PQgetvalue(res, i, i_srvacl));
+ srvinfo[i].srvtype = pg_strdup(PQgetvalue(res, i, i_srvtype));
+ srvinfo[i].srvversion = pg_strdup(PQgetvalue(res, i, i_srvversion));
+ srvinfo[i].srvoptions = pg_strdup(PQgetvalue(res, i, i_srvoptions));
+ srvinfo[i].srvacl = pg_strdup(PQgetvalue(res, i, i_srvacl));
/* Decide whether we want to dump it */
selectDumpableObject(&(srvinfo[i].dobj));
ntups = PQntuples(res);
*numDefaultACLs = ntups;
- daclinfo = (DefaultACLInfo *) malloc(ntups * sizeof(DefaultACLInfo));
+ daclinfo = (DefaultACLInfo *) pg_malloc(ntups * sizeof(DefaultACLInfo));
i_oid = PQfnumber(res, "oid");
i_tableoid = PQfnumber(res, "tableoid");
daclinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
AssignDumpId(&daclinfo[i].dobj);
/* cheesy ... is it worth coming up with a better object name? */
- daclinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_defaclobjtype));
+ daclinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_defaclobjtype));
if (nspid != InvalidOid)
daclinfo[i].dobj.namespace = findNamespace(nspid,
else
daclinfo[i].dobj.namespace = NULL;
- daclinfo[i].defaclrole = strdup(PQgetvalue(res, i, i_defaclrole));
+ daclinfo[i].defaclrole = pg_strdup(PQgetvalue(res, i, i_defaclrole));
daclinfo[i].defaclobjtype = *(PQgetvalue(res, i, i_defaclobjtype));
- daclinfo[i].defaclacl = strdup(PQgetvalue(res, i, i_defaclacl));
+ daclinfo[i].defaclacl = pg_strdup(PQgetvalue(res, i, i_defaclacl));
/* Decide whether we want to dump it */
selectDumpableDefaultACL(&(daclinfo[i]));
ntups = PQntuples(res);
- comments = (CommentItem *) malloc(ntups * sizeof(CommentItem));
+ comments = (CommentItem *) pg_malloc(ntups * sizeof(CommentItem));
for (i = 0; i < ntups; i++)
{
delq = createPQExpBuffer();
labelq = createPQExpBuffer();
- qnspname = strdup(fmtId(nspinfo->dobj.name));
+ qnspname = pg_strdup(fmtId(nspinfo->dobj.name));
appendPQExpBuffer(delq, "DROP SCHEMA %s;\n", qnspname);
delq = createPQExpBuffer();
labelq = createPQExpBuffer();
- qextname = strdup(fmtId(extinfo->dobj.name));
+ qextname = pg_strdup(fmtId(extinfo->dobj.name));
appendPQExpBuffer(delq, "DROP EXTENSION %s;\n", qextname);
delqry = createPQExpBuffer();
labelq = createPQExpBuffer();
- qlanname = strdup(fmtId(plang->dobj.name));
+ qlanname = pg_strdup(fmtId(plang->dobj.name));
/*
* If dumping a HANDLER clause, treat the language as being in the handler
char *paren;
bool inquote;
- name = strdup(proc);
+ name = pg_strdup(proc);
/* find non-double-quoted left paren */
inquote = false;
for (paren = name; *paren; paren++)
bool inquote;
bool sawdot;
- name = strdup(opr);
+ name = pg_strdup(opr);
/* find non-double-quoted left paren, and check for non-quoted dot */
inquote = false;
sawdot = false;
/* If not schema-qualified, don't need to add OPERATOR() */
if (!sawdot)
return name;
- oname = malloc(strlen(name) + 11);
+ oname = pg_malloc(strlen(name) + 11);
sprintf(oname, "OPERATOR(%s)", name);
free(name);
return oname;
exit_nicely();
}
- result = strdup(PQgetvalue(res, 0, 0));
+ result = pg_strdup(PQgetvalue(res, 0, 0));
PQclear(res);
opckeytype = PQgetvalue(res, 0, i_opckeytype);
opcdefault = PQgetvalue(res, 0, i_opcdefault);
/* opcfamily will still be needed after we PQclear res */
- opcfamily = strdup(PQgetvalue(res, 0, i_opcfamily));
+ opcfamily = pg_strdup(PQgetvalue(res, 0, i_opcfamily));
opcfamilyname = PQgetvalue(res, 0, i_opcfamilyname);
opcfamilynsp = PQgetvalue(res, 0, i_opcfamilynsp);
/* amname will still be needed after we PQclear res */
- amname = strdup(PQgetvalue(res, 0, i_amname));
+ amname = pg_strdup(PQgetvalue(res, 0, i_amname));
/*
* DROP must be fully qualified in case same name appears in pg_catalog
i_amname = PQfnumber(res, "amname");
/* amname will still be needed after we PQclear res */
- amname = strdup(PQgetvalue(res, 0, i_amname));
+ amname = pg_strdup(PQgetvalue(res, 0, i_amname));
/*
* DROP must be fully qualified in case same name appears in pg_catalog
delq = createPQExpBuffer();
labelq = createPQExpBuffer();
- qfdwname = strdup(fmtId(fdwinfo->dobj.name));
+ qfdwname = pg_strdup(fmtId(fdwinfo->dobj.name));
appendPQExpBuffer(q, "CREATE FOREIGN DATA WRAPPER %s",
qfdwname);
labelq = createPQExpBuffer();
query = createPQExpBuffer();
- qsrvname = strdup(fmtId(srvinfo->dobj.name));
+ qsrvname = pg_strdup(fmtId(srvinfo->dobj.name));
/* look up the foreign-data wrapper */
selectSourceSchema("pg_catalog");
ntups = PQntuples(res);
- labels = (SecLabelItem *) malloc(ntups * sizeof(SecLabelItem));
+ labels = (SecLabelItem *) pg_malloc(ntups * sizeof(SecLabelItem));
for (i = 0; i < ntups; i++)
{
dumpTableSchema(fout, tbinfo);
/* Handle the ACL here */
- namecopy = strdup(fmtId(tbinfo->dobj.name));
+ namecopy = pg_strdup(fmtId(tbinfo->dobj.name));
dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
(tbinfo->relkind == RELKIND_SEQUENCE) ? "SEQUENCE" :
"TABLE",
char *attnamecopy;
char *acltag;
- attnamecopy = strdup(fmtId(attname));
- acltag = malloc(strlen(tbinfo->dobj.name) + strlen(attname) + 2);
+ attnamecopy = pg_strdup(fmtId(attname));
+ acltag = pg_malloc(strlen(tbinfo->dobj.name) + strlen(attname) + 2);
sprintf(acltag, "%s.%s", tbinfo->dobj.name, attname);
/* Column's GRANT type is always TABLE */
dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId, "TABLE",
check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
i_srvname = PQfnumber(res, "srvname");
i_ftoptions = PQfnumber(res, "ftoptions");
- srvname = strdup(PQgetvalue(res, 0, i_srvname));
- ftoptions = strdup(PQgetvalue(res, 0, i_ftoptions));
+ srvname = pg_strdup(PQgetvalue(res, 0, i_srvname));
+ ftoptions = pg_strdup(PQgetvalue(res, 0, i_ftoptions));
PQclear(res);
}
else
*/
makeTableDataInfo(configtbl, false);
if (strlen(extconditionarray[j]) > 0)
- configtbl->dataObj->filtercond = strdup(extconditionarray[j]);
+ configtbl->dataObj->filtercond = pg_strdup(extconditionarray[j]);
}
}
}
destroyPQExpBuffer(query);
if (curSchemaName)
free(curSchemaName);
- curSchemaName = strdup(schemaName);
+ curSchemaName = pg_strdup(schemaName);
}
/*
if (oid == 0)
{
if ((opts & zeroAsOpaque) != 0)
- return strdup(g_opaque_type);
+ return pg_strdup(g_opaque_type);
else if ((opts & zeroAsAny) != 0)
- return strdup("'any'");
+ return pg_strdup("'any'");
else if ((opts & zeroAsStar) != 0)
- return strdup("*");
+ return pg_strdup("*");
else if ((opts & zeroAsNone) != 0)
- return strdup("NONE");
+ return pg_strdup("NONE");
}
query = createPQExpBuffer();
if (g_fout->remoteVersion >= 70100)
{
/* already quoted */
- result = strdup(PQgetvalue(res, 0, 0));
+ result = pg_strdup(PQgetvalue(res, 0, 0));
}
else
{
/* may need to quote it */
- result = strdup(fmtId(PQgetvalue(res, 0, 0)));
+ result = pg_strdup(fmtId(PQgetvalue(res, 0, 0)));
}
PQclear(res);
if (isarray)
appendPQExpBuffer(buf, "[]");
- result = strdup(buf->data);
+ result = pg_strdup(buf->data);
destroyPQExpBuffer(buf);
return result;
extern bool simple_oid_list_member(SimpleOidList *list, Oid val);
extern bool simple_string_list_member(SimpleStringList *list, const char *val);
-extern char *pg_strdup(const char *string);
-extern void *pg_malloc(size_t size);
-extern void *pg_calloc(size_t nmemb, size_t size);
-extern void *pg_realloc(void *ptr, size_t size);
-
extern void check_conn_and_db(void);
extern void exit_nicely(void);
*-------------------------------------------------------------------------
*/
#include "pg_backup_archiver.h"
-
+#include "common.h"
static const char *modulename = gettext_noop("sorter");
if (numObjs <= 0)
return;
- ordering = (DumpableObject **) malloc(numObjs * sizeof(DumpableObject *));
- if (ordering == NULL)
- exit_horribly(NULL, modulename, "out of memory\n");
-
+ ordering = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *));
while (!TopoSort(objs, numObjs, ordering, &nOrdering))
findDependencyLoops(ordering, nOrdering, numObjs);
return true;
/* Create workspace for the above-described heap */
- pendingHeap = (int *) malloc(numObjs * sizeof(int));
- if (pendingHeap == NULL)
- exit_horribly(NULL, modulename, "out of memory\n");
+ pendingHeap = (int *) pg_malloc(numObjs * sizeof(int));
/*
* Scan the constraints, and for each item in the input, generate a count
* We also make a map showing the input-order index of the item with
* dumpId j.
*/
- beforeConstraints = (int *) malloc((maxDumpId + 1) * sizeof(int));
- if (beforeConstraints == NULL)
- exit_horribly(NULL, modulename, "out of memory\n");
+ beforeConstraints = (int *) pg_malloc((maxDumpId + 1) * sizeof(int));
memset(beforeConstraints, 0, (maxDumpId + 1) * sizeof(int));
- idMap = (int *) malloc((maxDumpId + 1) * sizeof(int));
- if (idMap == NULL)
- exit_horribly(NULL, modulename, "out of memory\n");
+ idMap = (int *) pg_malloc((maxDumpId + 1) * sizeof(int));
for (i = 0; i < numObjs; i++)
{
obj = objs[i];
bool fixedloop;
int i;
- workspace = (DumpableObject **) malloc(totObjs * sizeof(DumpableObject *));
- if (workspace == NULL)
- exit_horribly(NULL, modulename, "out of memory\n");
+ workspace = (DumpableObject **) pg_malloc(totObjs * sizeof(DumpableObject *));
initiallen = 0;
fixedloop = false;
static PGresult *executeQuery(PGconn *conn, const char *query);
static void executeCommand(PGconn *conn, const char *query);
+char *pg_strdup(const char *string);
+void *pg_malloc(size_t size);
+
static char pg_dump_bin[MAXPGPATH];
static PQExpBuffer pgdumpopts;
static bool skip_acls = false;
if (strlen(grolist) < 3)
continue;
- grolist = strdup(grolist);
+ grolist = pg_strdup(grolist);
grolist[0] = '(';
grolist[strlen(grolist) - 1] = ')';
printfPQExpBuffer(buf,
char *fspcname;
/* needed for buildACLCommands() */
- fspcname = strdup(fmtId(spcname));
+ fspcname = pg_strdup(fmtId(spcname));
appendPQExpBuffer(buf, "CREATE TABLESPACE %s", fspcname);
appendPQExpBuffer(buf, " OWNER %s", fmtId(spcowner));
if (PQntuples(res) > 0)
{
if (!PQgetisnull(res, 0, 0))
- default_encoding = strdup(PQgetvalue(res, 0, 0));
+ default_encoding = pg_strdup(PQgetvalue(res, 0, 0));
if (!PQgetisnull(res, 0, 1))
- default_collate = strdup(PQgetvalue(res, 0, 1));
+ default_collate = pg_strdup(PQgetvalue(res, 0, 1));
if (!PQgetisnull(res, 0, 2))
- default_ctype = strdup(PQgetvalue(res, 0, 2));
+ default_ctype = pg_strdup(PQgetvalue(res, 0, 2));
}
PQclear(res);
char *dbtablespace = PQgetvalue(res, i, 9);
char *fdbname;
- fdbname = strdup(fmtId(dbname));
+ fdbname = pg_strdup(fmtId(dbname));
resetPQExpBuffer(buf);
char *mine;
PQExpBuffer buf = createPQExpBuffer();
- mine = strdup(arrayitem);
+ mine = pg_strdup(arrayitem);
pos = strchr(mine, '=');
if (pos == NULL)
return;
do
{
#define PARAMS_ARRAY_SIZE 7
- const char **keywords = malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
- const char **values = malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
-
- if (!keywords || !values)
- {
- fprintf(stderr, _("%s: out of memory\n"), progname);
- exit(1);
- }
+ const char **keywords = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
+ const char **values = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
keywords[0] = "host";
values[0] = pghost;
appendPQExpBufferChar(buf, '"');
#endif /* WIN32 */
}
+
+
+/*
+ * Simpler versions of common.c functions.
+ */
+
+char *
+pg_strdup(const char *string)
+{
+ char *tmp;
+
+ if (!string)
+ {
+ fprintf(stderr, "cannot duplicate null pointer\n");
+ exit(1);
+ }
+ tmp = strdup(string);
+ if (!tmp)
+ {
+ fprintf(stderr, _("%s: out of memory\n"), progname);
+ exit(1);
+ }
+ return tmp;
+}
+
+void *
+pg_malloc(size_t size)
+{
+ void *tmp;
+
+ tmp = malloc(size);
+ if (!tmp)
+ {
+ fprintf(stderr, _("%s: out of memory\n"), progname);
+ exit(1);
+ }
+ return tmp;
+}
*-------------------------------------------------------------------------
*/
+#include "common.h"
#include "pg_backup_archiver.h"
#include "dumputils.h"
opts->createDB = 1;
break;
case 'd':
- opts->dbname = strdup(optarg);
+ opts->dbname = pg_strdup(optarg);
break;
case 'e':
opts->exit_on_error = true;
break;
case 'f': /* output file name */
- opts->filename = strdup(optarg);
+ opts->filename = pg_strdup(optarg);
break;
case 'F':
if (strlen(optarg) != 0)
- opts->formatName = strdup(optarg);
+ opts->formatName = pg_strdup(optarg);
break;
case 'h':
if (strlen(optarg) != 0)
- opts->pghost = strdup(optarg);
+ opts->pghost = pg_strdup(optarg);
break;
case 'i':
/* ignored, deprecated option */
break;
case 'L': /* input TOC summary file name */
- opts->tocFile = strdup(optarg);
+ opts->tocFile = pg_strdup(optarg);
break;
case 'n': /* Dump data for this schema only */
- opts->schemaNames = strdup(optarg);
+ opts->schemaNames = pg_strdup(optarg);
break;
case 'O':
case 'p':
if (strlen(optarg) != 0)
- opts->pgport = strdup(optarg);
+ opts->pgport = pg_strdup(optarg);
break;
case 'R':
/* no-op, still accepted for backwards compatibility */
case 'P': /* Function */
opts->selTypes = 1;
opts->selFunction = 1;
- opts->functionNames = strdup(optarg);
+ opts->functionNames = pg_strdup(optarg);
break;
case 'I': /* Index */
opts->selTypes = 1;
opts->selIndex = 1;
- opts->indexNames = strdup(optarg);
+ opts->indexNames = pg_strdup(optarg);
break;
case 'T': /* Trigger */
opts->selTypes = 1;
opts->selTrigger = 1;
- opts->triggerNames = strdup(optarg);
+ opts->triggerNames = pg_strdup(optarg);
break;
case 's': /* dump schema only */
opts->schemaOnly = 1;
break;
case 'S': /* Superuser username */
if (strlen(optarg) != 0)
- opts->superuser = strdup(optarg);
+ opts->superuser = pg_strdup(optarg);
break;
case 't': /* Dump data for this table only */
opts->selTypes = 1;
opts->selTable = 1;
- opts->tableNames = strdup(optarg);
+ opts->tableNames = pg_strdup(optarg);
break;
case 'U':
projects / postgresql.git / commitdiff