Re: pg_dump vs malloc - Mailing list pgsql-hackers

From Bruce Momjian
Subject Re: pg_dump vs malloc
Date
Msg-id 201111142210.pAEMAH920036@momjian.us
Whole thread Raw
In response to Re: pg_dump vs malloc  (Alvaro Herrera <alvherre@commandprompt.com>)
Responses Re: pg_dump vs malloc
List pgsql-hackers
Alvaro Herrera wrote:
> Excerpts from Magnus Hagander's message of mié jun 22 11:25:43 -0400 2011:
> > On Fri, Jun 10, 2011 at 21:07, Tom Lane <tgl@sss.pgh.pa.us> wrote:
> > > Magnus Hagander <magnus@hagander.net> writes:
> > >> I came across a situation today with a pretty bad crash of pg_dump,
> > >> due to not checking the return code from malloc(). When looking
> > >> through the code, it seems there are a *lot* of places in pg_dump that
> > >> doesn't check the malloc return code.
> > >
> > >> But we do have a pg_malloc() function in there - but from what I can
> > >> tell it's only used very sparsely?
> > >
> > >> Shouldn't we be using that one more or less everywhere
> > >
> > > Yup.  Have at it.
> >
> > Something along the line of this?
>
> Huh, do you really need a new file for the four new functions?  What's
> wrong with common.c?

I developed the attached patch to handle this.  I moved the catalog code
from common.c into dumpcatalog.c, so there are just memory routines now
in common.c.  I created new memory routines in pg_dumpall.c because
there is no AH structure in pg_dumpall.c.  I then modified all the calls
to use the new routines, and removed the NULL return checks that were no
longer necessary.

--
  Bruce Momjian  <bruce@momjian.us>        http://momjian.us
  EnterpriseDB                             http://enterprisedb.com

  + It's impossible for everything to be true. +
diff --git a/src/bin/pg_dump/Makefile b/src/bin/pg_dump/Makefile
new file mode 100644
index 8410af1..9d13bec
*** a/src/bin/pg_dump/Makefile
--- b/src/bin/pg_dump/Makefile
*************** override CPPFLAGS := -I$(libpq_srcdir) $
*** 20,26 ****

  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)

  KEYWRDOBJS = keywords.o kwlookup.o

--- 20,26 ----

  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 common.o dumputils.o compress_io.o $(WIN32RES)

  KEYWRDOBJS = keywords.o kwlookup.o

*************** kwlookup.c: % : $(top_srcdir)/src/backen
*** 29,36 ****

  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_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)
--- 29,36 ----

  all: pg_dump pg_restore pg_dumpall

! 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)
*************** uninstall:
*** 50,53 ****
      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.okwlookup.c $(KEYWRDOBJS) 
--- 50,53 ----
      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 dumpcatalog.o pg_dump_sort.o pg_restore.o
pg_dumpall.okwlookup.c $(KEYWRDOBJS) 
diff --git a/src/bin/pg_dump/common.c b/src/bin/pg_dump/common.c
new file mode 100644
index bd81a2c..1a3f4cb
*** a/src/bin/pg_dump/common.c
--- b/src/bin/pg_dump/common.c
***************
*** 1,10 ****
  /*-------------------------------------------------------------------------
   *
   * 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.
   *
   * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
   * Portions Copyright (c) 1994, Regents of the University of California
--- 1,8 ----
  /*-------------------------------------------------------------------------
   *
   * common.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
***************
*** 16,992 ****
   *-------------------------------------------------------------------------
   */
  #include "postgres_fe.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.
   */

  char *
--- 14,29 ----
   *-------------------------------------------------------------------------
   */
  #include "postgres_fe.h"
+ #include "pg_backup.h"
+ #include "common.h"

  #include <ctype.h>

  /*
   * 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.
!  * We also report the program name and close the database connection.
   */

  char *
*************** pg_calloc(size_t nmemb, size_t size)
*** 1020,1026 ****

      tmp = calloc(nmemb, size);
      if (!tmp)
!         exit_horribly(NULL, NULL, "out of memory\n");
      return tmp;
  }

--- 57,63 ----

      tmp = calloc(nmemb, size);
      if (!tmp)
!         exit_horribly(NULL, NULL, _("out of memory\n"));
      return tmp;
  }

*************** pg_realloc(void *ptr, size_t size)
*** 1031,1036 ****

      tmp = realloc(ptr, size);
      if (!tmp)
!         exit_horribly(NULL, NULL, "out of memory\n");
      return tmp;
  }
--- 68,73 ----

      tmp = realloc(ptr, size);
      if (!tmp)
!         exit_horribly(NULL, NULL, _("out of memory\n"));
      return tmp;
  }
diff --git a/src/bin/pg_dump/common.h b/src/bin/pg_dump/common.h
new file mode 100644
index ...742d9f6
*** a/src/bin/pg_dump/common.h
--- b/src/bin/pg_dump/common.h
***************
*** 0 ****
--- 1,24 ----
+ /*-------------------------------------------------------------------------
+  *
+  * 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 */
diff --git a/src/bin/pg_dump/compress_io.c b/src/bin/pg_dump/compress_io.c
new file mode 100644
index 8540a75..8375762
*** a/src/bin/pg_dump/compress_io.c
--- b/src/bin/pg_dump/compress_io.c
***************
*** 53,58 ****
--- 53,59 ----
   */

  #include "compress_io.h"
+ #include "common.h"

  /*----------------------
   * Compressor API
*************** AllocateCompressor(int compression, Writ
*** 135,143 ****
          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->writeF = writeF;
      cs->comprAlg = alg;

--- 136,142 ----
          die_horribly(NULL, modulename, "not built with zlib support\n");
  #endif

!     cs = (CompressorState *) pg_calloc(1, sizeof(CompressorState));
      cs->writeF = writeF;
      cs->comprAlg = alg;

*************** InitCompressorZlib(CompressorState *cs,
*** 221,229 ****
  {
      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->zalloc = Z_NULL;
      zp->zfree = Z_NULL;
      zp->opaque = Z_NULL;
--- 220,226 ----
  {
      z_streamp    zp;

!     zp = cs->zp = (z_streamp) pg_malloc(sizeof(z_stream));
      zp->zalloc = Z_NULL;
      zp->zfree = Z_NULL;
      zp->opaque = Z_NULL;
*************** InitCompressorZlib(CompressorState *cs,
*** 233,244 ****
       * 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->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",
--- 230,238 ----
       * actually allocate one extra byte because some routines want to append a
       * trailing zero byte to the zlib output.
       */
!     cs->zlibOut = (char *) pg_malloc(ZLIB_OUT_SIZE + 1);
      cs->zlibOutSize = ZLIB_OUT_SIZE;

      if (deflateInit(zp, level) != Z_OK)
          die_horribly(NULL, modulename,
                       "could not initialize compression library: %s\n",
*************** ReadDataFromArchiveZlib(ArchiveHandle *A
*** 338,358 ****
      char       *buf;
      size_t        buflen;

!     zp = (z_streamp) malloc(sizeof(z_stream));
!     if (zp == NULL)
!         die_horribly(NULL, modulename, "out of memory\n");
      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");
      buflen = ZLIB_IN_SIZE;

!     out = malloc(ZLIB_OUT_SIZE + 1);
!     if (out == NULL)
!         die_horribly(NULL, modulename, "out of memory\n");

      if (inflateInit(zp) != Z_OK)
          die_horribly(NULL, modulename,
--- 332,346 ----
      char       *buf;
      size_t        buflen;

!     zp = (z_streamp) pg_malloc(sizeof(z_stream));
      zp->zalloc = Z_NULL;
      zp->zfree = Z_NULL;
      zp->opaque = Z_NULL;

!     buf = pg_malloc(ZLIB_IN_SIZE);
      buflen = ZLIB_IN_SIZE;

!     out = pg_malloc(ZLIB_OUT_SIZE + 1);

      if (inflateInit(zp) != Z_OK)
          die_horribly(NULL, modulename,
*************** ReadDataFromArchiveNone(ArchiveHandle *A
*** 417,425 ****
      char       *buf;
      size_t        buflen;

!     buf = malloc(ZLIB_OUT_SIZE);
!     if (buf == NULL)
!         die_horribly(NULL, modulename, "out of memory\n");
      buflen = ZLIB_OUT_SIZE;

      while ((cnt = readF(AH, &buf, &buflen)))
--- 405,411 ----
      char       *buf;
      size_t        buflen;

!     buf = pg_malloc(ZLIB_OUT_SIZE);
      buflen = ZLIB_OUT_SIZE;

      while ((cnt = readF(AH, &buf, &buflen)))
*************** cfopen_read(const char *path, const char
*** 491,500 ****
          if (fp == NULL)
          {
              int            fnamelen = strlen(path) + 4;
!             char       *fname = malloc(fnamelen);
!
!             if (fname == NULL)
!                 die_horribly(NULL, modulename, "Out of memory\n");

              snprintf(fname, fnamelen, "%s%s", path, ".gz");
              fp = cfopen(fname, mode, 1);
--- 477,483 ----
          if (fp == NULL)
          {
              int            fnamelen = strlen(path) + 4;
!             char       *fname = pg_malloc(fnamelen);

              snprintf(fname, fnamelen, "%s%s", path, ".gz");
              fp = cfopen(fname, mode, 1);
*************** cfopen_write(const char *path, const cha
*** 525,534 ****
      {
  #ifdef HAVE_LIBZ
          int            fnamelen = strlen(path) + 4;
!         char       *fname = malloc(fnamelen);
!
!         if (fname == NULL)
!             die_horribly(NULL, modulename, "Out of memory\n");

          snprintf(fname, fnamelen, "%s%s", path, ".gz");
          fp = cfopen(fname, mode, 1);
--- 508,514 ----
      {
  #ifdef HAVE_LIBZ
          int            fnamelen = strlen(path) + 4;
!         char       *fname = pg_malloc(fnamelen);

          snprintf(fname, fnamelen, "%s%s", path, ".gz");
          fp = cfopen(fname, mode, 1);
*************** cfopen_write(const char *path, const cha
*** 548,557 ****
  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");

      if (compression != 0)
      {
--- 528,534 ----
  cfp *
  cfopen(const char *path, const char *mode, int compression)
  {
!     cfp           *fp = pg_malloc(sizeof(cfp));

      if (compression != 0)
      {
diff --git a/src/bin/pg_dump/dumpcatalog.c b/src/bin/pg_dump/dumpcatalog.c
new file mode 100644
index ...9747d47
*** a/src/bin/pg_dump/dumpcatalog.c
--- b/src/bin/pg_dump/dumpcatalog.c
***************
*** 0 ****
--- 1,978 ----
+ /*-------------------------------------------------------------------------
+  *
+  * 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;
+ }
diff --git a/src/bin/pg_dump/dumputils.c b/src/bin/pg_dump/dumputils.c
new file mode 100644
index acce7f8..5cc012d
*** a/src/bin/pg_dump/dumputils.c
--- b/src/bin/pg_dump/dumputils.c
***************
*** 16,21 ****
--- 16,22 ----

  #include <ctype.h>

+ #include "common.h"
  #include "dumputils.h"

  #include "parser/keywords.h"
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
new file mode 100644
index f47af26..8fb8382
*** a/src/bin/pg_dump/pg_backup_archiver.c
--- b/src/bin/pg_dump/pg_backup_archiver.c
***************
*** 21,26 ****
--- 21,27 ----
   */

  #include "pg_backup_db.h"
+ #include "common.h"
  #include "dumputils.h"

  #include <ctype.h>
*************** restore_toc_entry(ArchiveHandle *AH, Toc
*** 541,547 ****
          {
              ahlog(AH, 1, "connecting to new database \"%s\"\n", te->tag);
              _reconnectToDB(AH, te->tag);
!             ropt->dbname = strdup(te->tag);
          }
      }

--- 542,548 ----
          {
              ahlog(AH, 1, "connecting to new database \"%s\"\n", te->tag);
              _reconnectToDB(AH, te->tag);
!             ropt->dbname = pg_strdup(te->tag);
          }
      }

*************** NewRestoreOptions(void)
*** 660,666 ****
  {
      RestoreOptions *opts;

!     opts = (RestoreOptions *) calloc(1, sizeof(RestoreOptions));

      /* set any fields that shouldn't default to zeroes */
      opts->format = archUnknown;
--- 661,667 ----
  {
      RestoreOptions *opts;

!     opts = (RestoreOptions *) pg_calloc(1, sizeof(RestoreOptions));

      /* set any fields that shouldn't default to zeroes */
      opts->format = archUnknown;
*************** ArchiveEntry(Archive *AHX,
*** 759,767 ****
      ArchiveHandle *AH = (ArchiveHandle *) AHX;
      TocEntry   *newToc;

!     newToc = (TocEntry *) calloc(1, sizeof(TocEntry));
!     if (!newToc)
!         die_horribly(AH, modulename, "out of memory\n");

      AH->tocCount++;
      if (dumpId > AH->maxDumpId)
--- 760,766 ----
      ArchiveHandle *AH = (ArchiveHandle *) AHX;
      TocEntry   *newToc;

!     newToc = (TocEntry *) pg_calloc(1, sizeof(TocEntry));

      AH->tocCount++;
      if (dumpId > AH->maxDumpId)
*************** ArchiveEntry(Archive *AHX,
*** 776,794 ****
      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->withOids = withOids;
!     newToc->desc = strdup(desc);
!     newToc->defn = strdup(defn);
!     newToc->dropStmt = strdup(dropStmt);
!     newToc->copyStmt = copyStmt ? strdup(copyStmt) : NULL;

      if (nDeps > 0)
      {
!         newToc->dependencies = (DumpId *) malloc(nDeps * sizeof(DumpId));
          memcpy(newToc->dependencies, deps, nDeps * sizeof(DumpId));
          newToc->nDeps = nDeps;
      }
--- 775,793 ----
      newToc->dumpId = dumpId;
      newToc->section = section;

!     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 = 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 *) pg_malloc(nDeps * sizeof(DumpId));
          memcpy(newToc->dependencies, deps, nDeps * sizeof(DumpId));
          newToc->nDeps = nDeps;
      }
*************** SortTocFromFile(Archive *AHX, RestoreOpt
*** 1032,1038 ****
      bool        incomplete_line;

      /* Allocate space for the 'wanted' array, and init it */
!     ropt->idWanted = (bool *) malloc(sizeof(bool) * AH->maxDumpId);
      memset(ropt->idWanted, 0, sizeof(bool) * AH->maxDumpId);

      /* Setup the file */
--- 1031,1037 ----
      bool        incomplete_line;

      /* Allocate space for the 'wanted' array, and init it */
!     ropt->idWanted = (bool *) pg_malloc(sizeof(bool) * AH->maxDumpId);
      memset(ropt->idWanted, 0, sizeof(bool) * AH->maxDumpId);

      /* Setup the file */
*************** InitDummyWantedList(Archive *AHX, Restor
*** 1120,1126 ****
      ArchiveHandle *AH = (ArchiveHandle *) AHX;

      /* Allocate space for the 'wanted' array, and init it to 1's */
!     ropt->idWanted = (bool *) malloc(sizeof(bool) * AH->maxDumpId);
      memset(ropt->idWanted, 1, sizeof(bool) * AH->maxDumpId);
  }

--- 1119,1125 ----
      ArchiveHandle *AH = (ArchiveHandle *) AHX;

      /* Allocate space for the 'wanted' array, and init it to 1's */
!     ropt->idWanted = (bool *) pg_malloc(sizeof(bool) * AH->maxDumpId);
      memset(ropt->idWanted, 1, sizeof(bool) * AH->maxDumpId);
  }

*************** archprintf(Archive *AH, const char *fmt,
*** 1155,1163 ****
          if (p != NULL)
              free(p);
          bSize *= 2;
!         p = (char *) malloc(bSize);
!         if (p == NULL)
!             exit_horribly(AH, modulename, "out of memory\n");
          va_start(ap, fmt);
          cnt = vsnprintf(p, bSize, fmt, ap);
          va_end(ap);
--- 1154,1160 ----
          if (p != NULL)
              free(p);
          bSize *= 2;
!         p = (char *) pg_malloc(bSize);
          va_start(ap, fmt);
          cnt = vsnprintf(p, bSize, fmt, ap);
          va_end(ap);
*************** ahprintf(ArchiveHandle *AH, const char *
*** 1286,1294 ****
          if (p != NULL)
              free(p);
          bSize *= 2;
!         p = (char *) malloc(bSize);
!         if (p == NULL)
!             die_horribly(AH, modulename, "out of memory\n");
          va_start(ap, fmt);
          cnt = vsnprintf(p, bSize, fmt, ap);
          va_end(ap);
--- 1283,1289 ----
          if (p != NULL)
              free(p);
          bSize *= 2;
!         p = (char *) pg_malloc(bSize);
          va_start(ap, fmt);
          cnt = vsnprintf(p, bSize, fmt, ap);
          va_end(ap);
*************** ReadStr(ArchiveHandle *AH)
*** 1756,1765 ****
          buf = NULL;
      else
      {
!         buf = (char *) malloc(l + 1);
!         if (!buf)
!             die_horribly(AH, modulename, "out of memory\n");
!
          if ((*AH->ReadBufPtr) (AH, (void *) buf, l) != l)
              die_horribly(AH, modulename, "unexpected end of file\n");

--- 1751,1757 ----
          buf = NULL;
      else
      {
!         buf = (char *) pg_malloc(l + 1);
          if ((*AH->ReadBufPtr) (AH, (void *) buf, l) != l)
              die_horribly(AH, modulename, "unexpected end of file\n");

*************** _discoverArchiveFormat(ArchiveHandle *AH
*** 1785,1791 ****
          free(AH->lookahead);

      AH->lookaheadSize = 512;
!     AH->lookahead = calloc(1, 512);
      AH->lookaheadLen = 0;
      AH->lookaheadPos = 0;

--- 1777,1783 ----
          free(AH->lookahead);

      AH->lookaheadSize = 512;
!     AH->lookahead = pg_calloc(1, 512);
      AH->lookaheadLen = 0;
      AH->lookaheadPos = 0;

*************** _allocAH(const char *FileSpec, const Arc
*** 1950,1958 ****
      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->debugLevel = 100; */

--- 1942,1948 ----
      write_msg(modulename, "allocating AH for %s, format %d\n", FileSpec, fmt);
  #endif

!     AH = (ArchiveHandle *) pg_calloc(1, sizeof(ArchiveHandle));

      /* AH->debugLevel = 100; */

*************** _allocAH(const char *FileSpec, const Arc
*** 1979,1990 ****
      AH->offSize = sizeof(pgoff_t);
      if (FileSpec)
      {
!         AH->fSpec = strdup(FileSpec);

          /*
           * Not used; maybe later....
           *
!          * AH->workDir = strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
           * i--) if (AH->workDir[i-1] == '/')
           */
      }
--- 1969,1980 ----
      AH->offSize = sizeof(pgoff_t);
      if (FileSpec)
      {
!         AH->fSpec = pg_strdup(FileSpec);

          /*
           * Not used; maybe later....
           *
!          * AH->workDir = pg_strdup(FileSpec); for(i=strlen(FileSpec) ; i > 0 ;
           * i--) if (AH->workDir[i-1] == '/')
           */
      }
*************** _allocAH(const char *FileSpec, const Arc
*** 1996,2004 ****
      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->next = AH->toc;
      AH->toc->prev = AH->toc;
--- 1986,1992 ----
      AH->currTablespace = NULL;    /* ditto */
      AH->currWithOids = -1;        /* force SET */

!     AH->toc = (TocEntry *) pg_calloc(1, sizeof(TocEntry));

      AH->toc->next = AH->toc;
      AH->toc->prev = AH->toc;
*************** ReadToc(ArchiveHandle *AH)
*** 2169,2175 ****

      for (i = 0; i < AH->tocCount; i++)
      {
!         te = (TocEntry *) calloc(1, sizeof(TocEntry));
          te->dumpId = ReadInt(AH);

          if (te->dumpId > AH->maxDumpId)
--- 2157,2163 ----

      for (i = 0; i < AH->tocCount; i++)
      {
!         te = (TocEntry *) pg_calloc(1, sizeof(TocEntry));
          te->dumpId = ReadInt(AH);

          if (te->dumpId > AH->maxDumpId)
*************** ReadToc(ArchiveHandle *AH)
*** 2255,2261 ****
          if (AH->version >= K_VERS_1_5)
          {
              depSize = 100;
!             deps = (DumpId *) malloc(sizeof(DumpId) * depSize);
              depIdx = 0;
              for (;;)
              {
--- 2243,2249 ----
          if (AH->version >= K_VERS_1_5)
          {
              depSize = 100;
!             deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
              depIdx = 0;
              for (;;)
              {
*************** static void
*** 2315,2321 ****
  processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
  {
      /* te->defn should have the form SET client_encoding = 'foo'; */
!     char       *defn = strdup(te->defn);
      char       *ptr1;
      char       *ptr2 = NULL;
      int            encoding;
--- 2303,2309 ----
  processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
  {
      /* te->defn should have the form SET client_encoding = 'foo'; */
!     char       *defn = pg_strdup(te->defn);
      char       *ptr1;
      char       *ptr2 = NULL;
      int            encoding;
*************** _becomeUser(ArchiveHandle *AH, const cha
*** 2660,2666 ****
       */
      if (AH->currUser)
          free(AH->currUser);
!     AH->currUser = strdup(user);
  }

  /*
--- 2648,2654 ----
       */
      if (AH->currUser)
          free(AH->currUser);
!     AH->currUser = pg_strdup(user);
  }

  /*
*************** _selectOutputSchema(ArchiveHandle *AH, c
*** 2729,2735 ****

      if (AH->currSchema)
          free(AH->currSchema);
!     AH->currSchema = strdup(schemaName);

      destroyPQExpBuffer(qry);
  }
--- 2717,2723 ----

      if (AH->currSchema)
          free(AH->currSchema);
!     AH->currSchema = pg_strdup(schemaName);

      destroyPQExpBuffer(qry);
  }
*************** _selectTablespace(ArchiveHandle *AH, con
*** 2790,2796 ****

      if (AH->currTablespace)
          free(AH->currTablespace);
!     AH->currTablespace = strdup(want);

      destroyPQExpBuffer(qry);
  }
--- 2778,2784 ----

      if (AH->currTablespace)
          free(AH->currTablespace);
!     AH->currTablespace = pg_strdup(want);

      destroyPQExpBuffer(qry);
  }
*************** _getObjectDescription(PQExpBuffer buf, T
*** 2872,2878 ****
          strcmp(type, "OPERATOR FAMILY") == 0)
      {
          /* Chop "DROP " off the front and make a modifiable copy */
!         char       *first = strdup(te->dropStmt + 5);
          char       *last;

          /* point to last character in string */
--- 2860,2866 ----
          strcmp(type, "OPERATOR FAMILY") == 0)
      {
          /* Chop "DROP " off the front and make a modifiable copy */
!         char       *first = pg_strdup(te->dropStmt + 5);
          char       *last;

          /* point to last character in string */
*************** restore_toc_entries_parallel(ArchiveHand
*** 3279,3285 ****

      ahlog(AH, 2, "entering restore_toc_entries_parallel\n");

!     slots = (ParallelSlot *) calloc(sizeof(ParallelSlot), n_slots);

      /* Adjust dependency information */
      fix_dependencies(AH);
--- 3267,3273 ----

      ahlog(AH, 2, "entering restore_toc_entries_parallel\n");

!     slots = (ParallelSlot *) pg_calloc(sizeof(ParallelSlot), n_slots);

      /* Adjust dependency information */
      fix_dependencies(AH);
*************** restore_toc_entries_parallel(ArchiveHand
*** 3431,3437 ****
                  par_list_remove(next_work_item);

                  /* this memory is dealloced in mark_work_done() */
!                 args = malloc(sizeof(RestoreArgs));
                  args->AH = CloneArchive(AH);
                  args->te = next_work_item;

--- 3419,3425 ----
                  par_list_remove(next_work_item);

                  /* this memory is dealloced in mark_work_done() */
!                 args = pg_malloc(sizeof(RestoreArgs));
                  args->AH = CloneArchive(AH);
                  args->te = next_work_item;

*************** reap_child(ParallelSlot *slots, int n_sl
*** 3550,3556 ****

      /* first time around only, make space for handles to listen on */
      if (handles == NULL)
!         handles = (HANDLE *) calloc(sizeof(HANDLE), n_slots);

      /* set up list of handles to listen to */
      for (snum = 0, tnum = 0; snum < n_slots; snum++)
--- 3538,3544 ----

      /* first time around only, make space for handles to listen on */
      if (handles == NULL)
!         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++)
*************** fix_dependencies(ArchiveHandle *AH)
*** 3898,3904 ****
       * the TOC items are marked as not being in any parallel-processing list.
       */
      maxDumpId = AH->maxDumpId;
!     tocsByDumpId = (TocEntry **) calloc(maxDumpId, sizeof(TocEntry *));
      for (te = AH->toc->next; te != AH->toc; te = te->next)
      {
          tocsByDumpId[te->dumpId - 1] = te;
--- 3886,3892 ----
       * the TOC items are marked as not being in any parallel-processing list.
       */
      maxDumpId = AH->maxDumpId;
!     tocsByDumpId = (TocEntry **) pg_calloc(maxDumpId, sizeof(TocEntry *));
      for (te = AH->toc->next; te != AH->toc; te = te->next)
      {
          tocsByDumpId[te->dumpId - 1] = te;
*************** fix_dependencies(ArchiveHandle *AH)
*** 3958,3964 ****
                  {
                      if (strcmp(te2->desc, "BLOBS") == 0)
                      {
!                         te->dependencies = (DumpId *) malloc(sizeof(DumpId));
                          te->dependencies[0] = te2->dumpId;
                          te->nDeps++;
                          te->depCount++;
--- 3946,3952 ----
                  {
                      if (strcmp(te2->desc, "BLOBS") == 0)
                      {
!                         te->dependencies = (DumpId *) pg_malloc(sizeof(DumpId));
                          te->dependencies[0] = te2->dumpId;
                          te->nDeps++;
                          te->depCount++;
*************** fix_dependencies(ArchiveHandle *AH)
*** 4000,4006 ****
      for (te = AH->toc->next; te != AH->toc; te = te->next)
      {
          if (te->nRevDeps > 0)
!             te->revDeps = (DumpId *) malloc(te->nRevDeps * sizeof(DumpId));
          te->nRevDeps = 0;
      }

--- 3988,3994 ----
      for (te = AH->toc->next; te != AH->toc; te = te->next)
      {
          if (te->nRevDeps > 0)
!             te->revDeps = (DumpId *) pg_malloc(te->nRevDeps * sizeof(DumpId));
          te->nRevDeps = 0;
      }

*************** identify_locking_dependencies(TocEntry *
*** 4092,4098 ****
       * 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));
      nlockids = 0;
      for (i = 0; i < te->nDeps; i++)
      {
--- 4080,4086 ----
       * that all the entry types we are interested in here are POST_DATA, so
       * they will all have been changed this way.)
       */
!     lockids = (DumpId *) pg_malloc(te->nDeps * sizeof(DumpId));
      nlockids = 0;
      for (i = 0; i < te->nDeps; i++)
      {
*************** CloneArchive(ArchiveHandle *AH)
*** 4204,4212 ****
      ArchiveHandle *clone;

      /* Make a "flat" copy */
!     clone = (ArchiveHandle *) malloc(sizeof(ArchiveHandle));
!     if (clone == NULL)
!         die_horribly(AH, modulename, "out of memory\n");
      memcpy(clone, AH, sizeof(ArchiveHandle));

      /* Handle format-independent fields ... none at the moment */
--- 4192,4198 ----
      ArchiveHandle *clone;

      /* Make a "flat" copy */
!     clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
      memcpy(clone, AH, sizeof(ArchiveHandle));

      /* Handle format-independent fields ... none at the moment */
*************** CloneArchive(ArchiveHandle *AH)
*** 4220,4226 ****

      /* savedPassword must be local in case we change it while connecting */
      if (clone->savedPassword)
!         clone->savedPassword = strdup(clone->savedPassword);

      /* clone has its own error count, too */
      clone->public.n_errors = 0;
--- 4206,4212 ----

      /* savedPassword must be local in case we change it while connecting */
      if (clone->savedPassword)
!         clone->savedPassword = pg_strdup(clone->savedPassword);

      /* clone has its own error count, too */
      clone->public.n_errors = 0;
diff --git a/src/bin/pg_dump/pg_backup_custom.c b/src/bin/pg_dump/pg_backup_custom.c
new file mode 100644
index 55ff39a..bfdf482
*** a/src/bin/pg_dump/pg_backup_custom.c
--- b/src/bin/pg_dump/pg_backup_custom.c
***************
*** 25,30 ****
--- 25,31 ----
   */

  #include "compress_io.h"
+ #include "common.h"

  /*--------
   * Routines in the format interface
*************** InitArchiveFmt_Custom(ArchiveHandle *AH)
*** 126,141 ****
      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");
      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");

      ctx->filePos = 0;

--- 127,138 ----
      AH->DeClonePtr = _DeClone;

      /* Set up a private area. */
!     ctx = (lclContext *) pg_calloc(1, sizeof(lclContext));
      AH->formatData = (void *) ctx;

      /* Initialize LO buffering */
      AH->lo_buf_size = LOBBUFSIZE;
!     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);

      ctx->filePos = 0;

*************** _ArchiveEntry(ArchiveHandle *AH, TocEntr
*** 199,205 ****
  {
      lclTocEntry *ctx;

!     ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper)
          ctx->dataState = K_OFFSET_POS_NOT_SET;
      else
--- 196,202 ----
  {
      lclTocEntry *ctx;

!     ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper)
          ctx->dataState = K_OFFSET_POS_NOT_SET;
      else
*************** _ReadExtraToc(ArchiveHandle *AH, TocEntr
*** 240,246 ****

      if (ctx == NULL)
      {
!         ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) ctx;
      }

--- 237,243 ----

      if (ctx == NULL)
      {
!         ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) ctx;
      }

*************** _skipData(ArchiveHandle *AH)
*** 566,572 ****
          {
              if (buf)
                  free(buf);
!             buf = (char *) malloc(blkLen);
              buflen = blkLen;
          }
          cnt = fread(buf, 1, blkLen, AH->FH);
--- 563,569 ----
          {
              if (buf)
                  free(buf);
!             buf = (char *) pg_malloc(blkLen);
              buflen = blkLen;
          }
          cnt = fread(buf, 1, blkLen, AH->FH);
*************** _Clone(ArchiveHandle *AH)
*** 774,782 ****
  {
      lclContext *ctx = (lclContext *) AH->formatData;

!     AH->formatData = (lclContext *) malloc(sizeof(lclContext));
!     if (AH->formatData == NULL)
!         die_horribly(AH, modulename, "out of memory\n");
      memcpy(AH->formatData, ctx, sizeof(lclContext));
      ctx = (lclContext *) AH->formatData;

--- 771,777 ----
  {
      lclContext *ctx = (lclContext *) AH->formatData;

!     AH->formatData = (lclContext *) pg_malloc(sizeof(lclContext));
      memcpy(AH->formatData, ctx, sizeof(lclContext));
      ctx = (lclContext *) AH->formatData;

*************** _CustomReadFunc(ArchiveHandle *AH, char
*** 901,909 ****
      if (blkLen > *buflen)
      {
          free(*buf);
!         *buf = (char *) malloc(blkLen);
!         if (!(*buf))
!             die_horribly(AH, modulename, "out of memory\n");
          *buflen = blkLen;
      }

--- 896,902 ----
      if (blkLen > *buflen)
      {
          free(*buf);
!         *buf = (char *) pg_malloc(blkLen);
          *buflen = blkLen;
      }

diff --git a/src/bin/pg_dump/pg_backup_db.c b/src/bin/pg_dump/pg_backup_db.c
new file mode 100644
index 600728d..a58eb2d
*** a/src/bin/pg_dump/pg_backup_db.c
--- b/src/bin/pg_dump/pg_backup_db.c
***************
*** 11,16 ****
--- 11,17 ----
   */

  #include "pg_backup_db.h"
+ #include "common.h"
  #include "dumputils.h"

  #include <unistd.h>
*************** _check_database_version(ArchiveHandle *A
*** 55,61 ****

      remoteversion = _parse_version(AH, remoteversion_str);

!     AH->public.remoteVersionStr = strdup(remoteversion_str);
      AH->public.remoteVersion = remoteversion;
      if (!AH->archiveRemoteVersion)
          AH->archiveRemoteVersion = AH->public.remoteVersionStr;
--- 56,62 ----

      remoteversion = _parse_version(AH, remoteversion_str);

!     AH->public.remoteVersionStr = pg_strdup(remoteversion_str);
      AH->public.remoteVersion = remoteversion;
      if (!AH->archiveRemoteVersion)
          AH->archiveRemoteVersion = AH->public.remoteVersionStr;
*************** _connectDB(ArchiveHandle *AH, const char
*** 150,160 ****
      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");

          keywords[0] = "host";
          values[0] = PQhost(AH->connection);
--- 151,158 ----
      do
      {
  #define PARAMS_ARRAY_SIZE    7
!         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);
*************** ConnectDatabase(Archive *AHX,
*** 257,267 ****
      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");

          keywords[0] = "host";
          values[0] = pghost;
--- 255,262 ----
      do
      {
  #define PARAMS_ARRAY_SIZE    7
!         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;
*************** ExecuteSqlCommandBuf(ArchiveHandle *AH,
*** 397,406 ****
              ExecuteSqlCommand(AH, buf, "could not execute query");
          else
          {
!             char   *str = (char *) 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");
--- 392,399 ----
              ExecuteSqlCommand(AH, buf, "could not execute query");
          else
          {
!             char   *str = (char *) pg_malloc(bufLen + 1);

              memcpy(str, buf, bufLen);
              str[bufLen] = '\0';
              ExecuteSqlCommand(AH, str, "could not execute query");
diff --git a/src/bin/pg_dump/pg_backup_directory.c b/src/bin/pg_dump/pg_backup_directory.c
new file mode 100644
index 2e110ac..4f9fcc2
*** a/src/bin/pg_dump/pg_backup_directory.c
--- b/src/bin/pg_dump/pg_backup_directory.c
***************
*** 34,39 ****
--- 34,40 ----
   */

  #include "compress_io.h"
+ #include "common.h"

  #include <dirent.h>
  #include <sys/stat.h>
*************** InitArchiveFmt_Directory(ArchiveHandle *
*** 125,133 ****
      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");
      AH->formatData = (void *) ctx;

      ctx->dataFH = NULL;
--- 126,132 ----
      AH->DeClonePtr = NULL;

      /* Set up our private context */
!     ctx = (lclContext *) pg_calloc(1, sizeof(lclContext));
      AH->formatData = (void *) ctx;

      ctx->dataFH = NULL;
*************** InitArchiveFmt_Directory(ArchiveHandle *
*** 135,143 ****

      /* 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");

      /*
       * Now open the TOC file
--- 134,140 ----

      /* Initialize LO buffering */
      AH->lo_buf_size = LOBBUFSIZE;
!     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);

      /*
       * Now open the TOC file
*************** _ArchiveEntry(ArchiveHandle *AH, TocEntr
*** 196,211 ****
      lclTocEntry *tctx;
      char        fn[MAXPGPATH];

!     tctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
!     if (!tctx)
!         die_horribly(AH, modulename, "out of memory\n");
      if (te->dataDumper)
      {
          snprintf(fn, MAXPGPATH, "%d.dat", te->dumpId);
!         tctx->filename = strdup(fn);
      }
      else if (strcmp(te->desc, "BLOBS") == 0)
!         tctx->filename = strdup("blobs.toc");
      else
          tctx->filename = NULL;

--- 193,206 ----
      lclTocEntry *tctx;
      char        fn[MAXPGPATH];

!     tctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper)
      {
          snprintf(fn, MAXPGPATH, "%d.dat", te->dumpId);
!         tctx->filename = pg_strdup(fn);
      }
      else if (strcmp(te->desc, "BLOBS") == 0)
!         tctx->filename = pg_strdup("blobs.toc");
      else
          tctx->filename = NULL;

*************** _ReadExtraToc(ArchiveHandle *AH, TocEntr
*** 247,255 ****

      if (tctx == NULL)
      {
!         tctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
!         if (!tctx)
!             die_horribly(AH, modulename, "out of memory\n");
          te->formatData = (void *) tctx;
      }

--- 242,248 ----

      if (tctx == NULL)
      {
!         tctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) tctx;
      }

*************** _PrintFileData(ArchiveHandle *AH, char *
*** 355,363 ****
          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");
      buflen = ZLIB_OUT_SIZE;

      while ((cnt = cfread(buf, buflen, cfp)))
--- 348,354 ----
          die_horribly(AH, modulename, "could not open input file \"%s\": %s\n",
                       filename, strerror(errno));

!     buf = pg_malloc(ZLIB_OUT_SIZE);
      buflen = ZLIB_OUT_SIZE;

      while ((cnt = cfread(buf, buflen, cfp)))
diff --git a/src/bin/pg_dump/pg_backup_files.c b/src/bin/pg_dump/pg_backup_files.c
new file mode 100644
index afd53bf..76366e1
*** a/src/bin/pg_dump/pg_backup_files.c
--- b/src/bin/pg_dump/pg_backup_files.c
***************
*** 26,31 ****
--- 26,32 ----
   */

  #include "pg_backup_archiver.h"
+ #include "common.h"

  static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te);
  static void _StartData(ArchiveHandle *AH, TocEntry *te);
*************** InitArchiveFmt_Files(ArchiveHandle *AH)
*** 103,117 ****
      /*
       * Set up some special context used in compressing data.
       */
!     ctx = (lclContext *) 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");

      /*
       * Now open the TOC file
--- 104,116 ----
      /*
       * Set up some special context used in compressing data.
       */
!     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 *) pg_malloc(LOBBUFSIZE);

      /*
       * Now open the TOC file
*************** _ArchiveEntry(ArchiveHandle *AH, TocEntr
*** 183,189 ****
      lclTocEntry *ctx;
      char        fn[K_STD_BUF_SIZE];

!     ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper)
      {
  #ifdef HAVE_LIBZ
--- 182,188 ----
      lclTocEntry *ctx;
      char        fn[K_STD_BUF_SIZE];

!     ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper)
      {
  #ifdef HAVE_LIBZ
*************** _ArchiveEntry(ArchiveHandle *AH, TocEntr
*** 194,200 ****
  #else
          sprintf(fn, "%d.dat", te->dumpId);
  #endif
!         ctx->filename = strdup(fn);
      }
      else
      {
--- 193,199 ----
  #else
          sprintf(fn, "%d.dat", te->dumpId);
  #endif
!         ctx->filename = pg_strdup(fn);
      }
      else
      {
*************** _ReadExtraToc(ArchiveHandle *AH, TocEntr
*** 222,228 ****

      if (ctx == NULL)
      {
!         ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) ctx;
      }

--- 221,227 ----

      if (ctx == NULL)
      {
!         ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) ctx;
      }

diff --git a/src/bin/pg_dump/pg_backup_null.c b/src/bin/pg_dump/pg_backup_null.c
new file mode 100644
index bf1e6e6..252e7a4
*** a/src/bin/pg_dump/pg_backup_null.c
--- b/src/bin/pg_dump/pg_backup_null.c
***************
*** 23,28 ****
--- 23,29 ----
   */

  #include "pg_backup_archiver.h"
+ #include "common.h"
  #include "dumputils.h"

  #include <unistd.h>                /* for dup */
*************** InitArchiveFmt_Null(ArchiveHandle *AH)
*** 67,75 ****

      /* 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");

      /*
       * Now prevent reading...
--- 68,74 ----

      /* Initialize LO buffering */
      AH->lo_buf_size = LOBBUFSIZE;
!     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);

      /*
       * Now prevent reading...
diff --git a/src/bin/pg_dump/pg_backup_tar.c b/src/bin/pg_dump/pg_backup_tar.c
new file mode 100644
index 4642132..94133cf
*** a/src/bin/pg_dump/pg_backup_tar.c
--- b/src/bin/pg_dump/pg_backup_tar.c
***************
*** 28,33 ****
--- 28,34 ----
  #include "pg_backup.h"
  #include "pg_backup_archiver.h"
  #include "pg_backup_tar.h"
+ #include "common.h"

  #include <sys/stat.h>
  #include <ctype.h>
*************** InitArchiveFmt_Tar(ArchiveHandle *AH)
*** 159,174 ****
      /*
       * Set up some special context used in compressing data.
       */
!     ctx = (lclContext *) 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");

      /*
       * Now open the tar file, and load the TOC if we're in read mode.
--- 160,173 ----
      /*
       * Set up some special context used in compressing data.
       */
!     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 *) pg_malloc(LOBBUFSIZE);

      /*
       * Now open the tar file, and load the TOC if we're in read mode.
*************** _ArchiveEntry(ArchiveHandle *AH, TocEntr
*** 267,273 ****
      lclTocEntry *ctx;
      char        fn[K_STD_BUF_SIZE];

!     ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper != NULL)
      {
  #ifdef HAVE_LIBZ
--- 266,272 ----
      lclTocEntry *ctx;
      char        fn[K_STD_BUF_SIZE];

!     ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
      if (te->dataDumper != NULL)
      {
  #ifdef HAVE_LIBZ
*************** _ArchiveEntry(ArchiveHandle *AH, TocEntr
*** 278,284 ****
  #else
          sprintf(fn, "%d.dat", te->dumpId);
  #endif
!         ctx->filename = strdup(fn);
      }
      else
      {
--- 277,283 ----
  #else
          sprintf(fn, "%d.dat", te->dumpId);
  #endif
!         ctx->filename = pg_strdup(fn);
      }
      else
      {
*************** _ReadExtraToc(ArchiveHandle *AH, TocEntr
*** 306,312 ****

      if (ctx == NULL)
      {
!         ctx = (lclTocEntry *) calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) ctx;
      }

--- 305,311 ----

      if (ctx == NULL)
      {
!         ctx = (lclTocEntry *) pg_calloc(1, sizeof(lclTocEntry));
          te->formatData = (void *) ctx;
      }

*************** tarOpen(ArchiveHandle *AH, const char *f
*** 379,385 ****
      }
      else
      {
!         tm = calloc(1, sizeof(TAR_MEMBER));

  #ifndef WIN32
          tm->tmpFH = tmpfile();
--- 378,384 ----
      }
      else
      {
!         tm = pg_calloc(1, sizeof(TAR_MEMBER));

  #ifndef WIN32
          tm->tmpFH = tmpfile();
*************** tarOpen(ArchiveHandle *AH, const char *f
*** 432,438 ****
  #endif

          tm->AH = AH;
!         tm->targetFile = strdup(filename);
      }

      tm->mode = mode;
--- 431,437 ----
  #endif

          tm->AH = AH;
!         tm->targetFile = pg_strdup(filename);
      }

      tm->mode = mode;
*************** _PrintTocData(ArchiveHandle *AH, TocEntr
*** 665,671 ****
          ahprintf(AH, "\\.\n");

          /* Get a copy of the COPY statement and clean it up */
!         tmpCopy = strdup(te->copyStmt);
          for (i = 0; i < strlen(tmpCopy); i++)
              tmpCopy[i] = pg_tolower((unsigned char) tmpCopy[i]);

--- 664,670 ----
          ahprintf(AH, "\\.\n");

          /* Get a copy of the COPY statement and clean it up */
!         tmpCopy = pg_strdup(te->copyStmt);
          for (i = 0; i < strlen(tmpCopy); i++)
              tmpCopy[i] = pg_tolower((unsigned char) tmpCopy[i]);

*************** tarPrintf(ArchiveHandle *AH, TAR_MEMBER
*** 1010,1018 ****
          if (p != NULL)
              free(p);
          bSize *= 2;
!         p = (char *) malloc(bSize);
!         if (p == NULL)
!             die_horribly(AH, modulename, "out of memory\n");
          va_start(ap, fmt);
          cnt = vsnprintf(p, bSize, fmt, ap);
          va_end(ap);
--- 1009,1015 ----
          if (p != NULL)
              free(p);
          bSize *= 2;
!         p = (char *) pg_malloc(bSize);
          va_start(ap, fmt);
          cnt = vsnprintf(p, bSize, fmt, ap);
          va_end(ap);
*************** static TAR_MEMBER *
*** 1125,1131 ****
  _tarPositionTo(ArchiveHandle *AH, const char *filename)
  {
      lclContext *ctx = (lclContext *) AH->formatData;
!     TAR_MEMBER *th = calloc(1, sizeof(TAR_MEMBER));
      char        c;
      char        header[512];
      size_t        i,
--- 1122,1128 ----
  _tarPositionTo(ArchiveHandle *AH, const char *filename)
  {
      lclContext *ctx = (lclContext *) AH->formatData;
!     TAR_MEMBER *th = pg_calloc(1, sizeof(TAR_MEMBER));
      char        c;
      char        header[512];
      size_t        i,
*************** _tarGetHeader(ArchiveHandle *AH, TAR_MEM
*** 1295,1301 ****
                       tag, sum, chk, buf);
      }

!     th->targetFile = strdup(tag);
      th->fileLen = len;

      return 1;
--- 1292,1298 ----
                       tag, sum, chk, buf);
      }

!     th->targetFile = pg_strdup(tag);
      th->fileLen = len;

      return 1;
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
new file mode 100644
index 973f0b3..096db6d
*** a/src/bin/pg_dump/pg_dump.c
--- b/src/bin/pg_dump/pg_dump.c
***************
*** 58,63 ****
--- 58,64 ----
  #include "libpq/libpq-fs.h"

  #include "pg_backup_archiver.h"
+ #include "common.h"
  #include "dumputils.h"

  extern char *optarg;
*************** main(int argc, char **argv)
*** 439,445 ****
                  break;

              case 'S':            /* Username for superuser in plain text output */
!                 outputSuperuser = strdup(optarg);
                  break;

              case 't':            /* include table(s) */
--- 440,446 ----
                  break;

              case 'S':            /* Username for superuser in plain text output */
!                 outputSuperuser = pg_strdup(optarg);
                  break;

              case 't':            /* include table(s) */
*************** makeTableDataInfo(TableInfo *tbinfo, boo
*** 1586,1592 ****
  {
      TableDataInfo *tdinfo;

!     tdinfo = (TableDataInfo *) malloc(sizeof(TableDataInfo));

      tdinfo->dobj.objType = DO_TABLE_DATA;

--- 1587,1593 ----
  {
      TableDataInfo *tdinfo;

!     tdinfo = (TableDataInfo *) pg_malloc(sizeof(TableDataInfo));

      tdinfo->dobj.objType = DO_TABLE_DATA;

*************** getBlobs(Archive *AH)
*** 2182,2188 ****
          /*
           * Each large object has its own BLOB archive entry.
           */
!         binfo = (BlobInfo *) malloc(ntups * sizeof(BlobInfo));

          for (i = 0; i < ntups; i++)
          {
--- 2183,2189 ----
          /*
           * Each large object has its own BLOB archive entry.
           */
!         binfo = (BlobInfo *) pg_malloc(ntups * sizeof(BlobInfo));

          for (i = 0; i < ntups; i++)
          {
*************** getBlobs(Archive *AH)
*** 2191,2203 ****
              binfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, 0));
              AssignDumpId(&binfo[i].dobj);

!             binfo[i].dobj.name = strdup(PQgetvalue(res, i, 0));
              if (!PQgetisnull(res, i, 1))
!                 binfo[i].rolname = strdup(PQgetvalue(res, i, 1));
              else
                  binfo[i].rolname = "";
              if (!PQgetisnull(res, i, 2))
!                 binfo[i].blobacl = strdup(PQgetvalue(res, i, 2));
              else
                  binfo[i].blobacl = NULL;
          }
--- 2192,2204 ----
              binfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, 0));
              AssignDumpId(&binfo[i].dobj);

!             binfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, 0));
              if (!PQgetisnull(res, i, 1))
!                 binfo[i].rolname = pg_strdup(PQgetvalue(res, i, 1));
              else
                  binfo[i].rolname = "";
              if (!PQgetisnull(res, i, 2))
!                 binfo[i].blobacl = pg_strdup(PQgetvalue(res, i, 2));
              else
                  binfo[i].blobacl = NULL;
          }
*************** getBlobs(Archive *AH)
*** 2206,2216 ****
           * 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->objType = DO_BLOB_DATA;
          bdata->catId = nilCatalogId;
          AssignDumpId(bdata);
!         bdata->name = strdup("BLOBS");
      }

      PQclear(res);
--- 2207,2217 ----
           * 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 *) pg_malloc(sizeof(DumpableObject));
          bdata->objType = DO_BLOB_DATA;
          bdata->catId = nilCatalogId;
          AssignDumpId(bdata);
!         bdata->name = pg_strdup("BLOBS");
      }

      PQclear(res);
*************** getNamespaces(int *numNamespaces)
*** 2609,2623 ****
       */
      if (g_fout->remoteVersion < 70300)
      {
!         nsinfo = (NamespaceInfo *) 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("");

          selectDumpableNamespace(&nsinfo[0]);

--- 2610,2624 ----
       */
      if (g_fout->remoteVersion < 70300)
      {
!         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 = pg_strdup("public");
!         nsinfo[0].rolname = pg_strdup("");
!         nsinfo[0].nspacl = pg_strdup("");

          selectDumpableNamespace(&nsinfo[0]);

*************** getNamespaces(int *numNamespaces)
*** 2625,2633 ****
          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("");

          selectDumpableNamespace(&nsinfo[1]);

--- 2626,2634 ----
          nsinfo[1].dobj.catId.tableoid = 0;
          nsinfo[1].dobj.catId.oid = 1;
          AssignDumpId(&nsinfo[1].dobj);
!         nsinfo[1].dobj.name = pg_strdup("pg_catalog");
!         nsinfo[1].rolname = pg_strdup("");
!         nsinfo[1].nspacl = pg_strdup("");

          selectDumpableNamespace(&nsinfo[1]);

*************** getNamespaces(int *numNamespaces)
*** 2656,2662 ****

      ntups = PQntuples(res);

!     nsinfo = (NamespaceInfo *) malloc(ntups * sizeof(NamespaceInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 2657,2663 ----

      ntups = PQntuples(res);

!     nsinfo = (NamespaceInfo *) pg_malloc(ntups * sizeof(NamespaceInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getNamespaces(int *numNamespaces)
*** 2670,2678 ****
          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));

          /* Decide whether to dump this namespace */
          selectDumpableNamespace(&nsinfo[i]);
--- 2671,2679 ----
          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 = 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]);
*************** getExtensions(int *numExtensions)
*** 2777,2783 ****

      ntups = PQntuples(res);

!     extinfo = (ExtensionInfo *) malloc(ntups * sizeof(ExtensionInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 2778,2784 ----

      ntups = PQntuples(res);

!     extinfo = (ExtensionInfo *) pg_malloc(ntups * sizeof(ExtensionInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getExtensions(int *numExtensions)
*** 2794,2805 ****
          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].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));

          /* Decide whether we want to dump it */
          selectDumpableExtension(&(extinfo[i]));
--- 2795,2806 ----
          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 = 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 = 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]));
*************** getTypes(int *numTypes)
*** 2930,2936 ****

      ntups = PQntuples(res);

!     tyinfo = (TypeInfo *) malloc(ntups * sizeof(TypeInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 2931,2937 ----

      ntups = PQntuples(res);

!     tyinfo = (TypeInfo *) pg_malloc(ntups * sizeof(TypeInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getTypes(int *numTypes)
*** 2952,2961 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_typnamespace)),
                                                   tyinfo[i].dobj.catId.oid);
!         tyinfo[i].rolname = 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);
--- 2953,2962 ----
          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 = 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 = 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);
*************** getTypes(int *numTypes)
*** 2995,3005 ****
          if (tyinfo[i].dobj.dump && (tyinfo[i].typtype == TYPTYPE_BASE ||
                                      tyinfo[i].typtype == TYPTYPE_RANGE))
          {
!             stinfo = (ShellTypeInfo *) 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.namespace = tyinfo[i].dobj.namespace;
              stinfo->baseType = &(tyinfo[i]);
              tyinfo[i].shellType = stinfo;
--- 2996,3006 ----
          if (tyinfo[i].dobj.dump && (tyinfo[i].typtype == TYPTYPE_BASE ||
                                      tyinfo[i].typtype == TYPTYPE_RANGE))
          {
!             stinfo = (ShellTypeInfo *) pg_malloc(sizeof(ShellTypeInfo));
              stinfo->dobj.objType = DO_SHELL_TYPE;
              stinfo->dobj.catId = nilCatalogId;
              AssignDumpId(&stinfo->dobj);
!             stinfo->dobj.name = pg_strdup(tyinfo[i].dobj.name);
              stinfo->dobj.namespace = tyinfo[i].dobj.namespace;
              stinfo->baseType = &(tyinfo[i]);
              tyinfo[i].shellType = stinfo;
*************** getOperators(int *numOprs)
*** 3134,3140 ****
      ntups = PQntuples(res);
      *numOprs = ntups;

!     oprinfo = (OprInfo *) malloc(ntups * sizeof(OprInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3135,3141 ----
      ntups = PQntuples(res);
      *numOprs = ntups;

!     oprinfo = (OprInfo *) pg_malloc(ntups * sizeof(OprInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getOperators(int *numOprs)
*** 3149,3158 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_oprnamespace)),
                                                    oprinfo[i].dobj.catId.oid);
!         oprinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
          oprinfo[i].oprcode = atooid(PQgetvalue(res, i, i_oprcode));

          /* Decide whether we want to dump it */
--- 3150,3159 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_rolname));
          oprinfo[i].oprcode = atooid(PQgetvalue(res, i, i_oprcode));

          /* Decide whether we want to dump it */
*************** getCollations(int *numCollations)
*** 3218,3224 ****
      ntups = PQntuples(res);
      *numCollations = ntups;

!     collinfo = (CollInfo *) malloc(ntups * sizeof(CollInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3219,3225 ----
      ntups = PQntuples(res);
      *numCollations = ntups;

!     collinfo = (CollInfo *) pg_malloc(ntups * sizeof(CollInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getCollations(int *numCollations)
*** 3232,3241 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_collnamespace)),
                                                   collinfo[i].dobj.catId.oid);
!         collinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(collinfo[i].dobj));
--- 3233,3242 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(collinfo[i].dobj));
*************** getConversions(int *numConversions)
*** 3296,3302 ****
      ntups = PQntuples(res);
      *numConversions = ntups;

!     convinfo = (ConvInfo *) malloc(ntups * sizeof(ConvInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3297,3303 ----
      ntups = PQntuples(res);
      *numConversions = ntups;

!     convinfo = (ConvInfo *) pg_malloc(ntups * sizeof(ConvInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getConversions(int *numConversions)
*** 3310,3319 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_connamespace)),
                                                   convinfo[i].dobj.catId.oid);
!         convinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(convinfo[i].dobj));
--- 3311,3320 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(convinfo[i].dobj));
*************** getOpclasses(int *numOpclasses)
*** 3386,3392 ****
      ntups = PQntuples(res);
      *numOpclasses = ntups;

!     opcinfo = (OpclassInfo *) malloc(ntups * sizeof(OpclassInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3387,3393 ----
      ntups = PQntuples(res);
      *numOpclasses = ntups;

!     opcinfo = (OpclassInfo *) pg_malloc(ntups * sizeof(OpclassInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getOpclasses(int *numOpclasses)
*** 3400,3409 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_opcnamespace)),
                                                    opcinfo[i].dobj.catId.oid);
!         opcinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(opcinfo[i].dobj));
--- 3401,3410 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(opcinfo[i].dobj));
*************** getOpfamilies(int *numOpfamilies)
*** 3473,3479 ****
      ntups = PQntuples(res);
      *numOpfamilies = ntups;

!     opfinfo = (OpfamilyInfo *) malloc(ntups * sizeof(OpfamilyInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3474,3480 ----
      ntups = PQntuples(res);
      *numOpfamilies = ntups;

!     opfinfo = (OpfamilyInfo *) pg_malloc(ntups * sizeof(OpfamilyInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getOpfamilies(int *numOpfamilies)
*** 3487,3496 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_opfnamespace)),
                                                    opfinfo[i].dobj.catId.oid);
!         opfinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(opfinfo[i].dobj));
--- 3488,3497 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_rolname));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(opfinfo[i].dobj));
*************** getAggregates(int *numAggs)
*** 3613,3619 ****
      ntups = PQntuples(res);
      *numAggs = ntups;

!     agginfo = (AggInfo *) malloc(ntups * sizeof(AggInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3614,3620 ----
      ntups = PQntuples(res);
      *numAggs = ntups;

!     agginfo = (AggInfo *) pg_malloc(ntups * sizeof(AggInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getAggregates(int *numAggs)
*** 3630,3651 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_aggnamespace)),
                                              agginfo[i].aggfn.dobj.catId.oid);
!         agginfo[i].aggfn.rolname = 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.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));
              if (g_fout->remoteVersion >= 70300)
                  parseOidArray(PQgetvalue(res, i, i_proargtypes),
                                agginfo[i].aggfn.argtypes,
--- 3631,3652 ----
          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 = 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 = 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 = 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 *) pg_malloc(agginfo[i].aggfn.nargs * sizeof(Oid));
              if (g_fout->remoteVersion >= 70300)
                  parseOidArray(PQgetvalue(res, i, i_proargtypes),
                                agginfo[i].aggfn.argtypes,
*************** getFuncs(int *numFuncs)
*** 3788,3794 ****

      *numFuncs = ntups;

!     finfo = (FuncInfo *) calloc(ntups, sizeof(FuncInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 3789,3795 ----

      *numFuncs = ntups;

!     finfo = (FuncInfo *) pg_calloc(ntups, sizeof(FuncInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getFuncs(int *numFuncs)
*** 3807,3826 ****
          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.namespace =
              findNamespace(atooid(PQgetvalue(res, i, i_pronamespace)),
                            finfo[i].dobj.catId.oid);
!         finfo[i].rolname = 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].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));
              parseOidArray(PQgetvalue(res, i, i_proargtypes),
                            finfo[i].argtypes, finfo[i].nargs);
          }
--- 3808,3827 ----
          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 = 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 = 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 = 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 *) pg_malloc(finfo[i].nargs * sizeof(Oid));
              parseOidArray(PQgetvalue(res, i, i_proargtypes),
                            finfo[i].argtypes, finfo[i].nargs);
          }
*************** getTables(int *numTables)
*** 4217,4223 ****
       * only one, because we don't yet know which tables might be inheritance
       * ancestors of the target table.
       */
!     tblinfo = (TableInfo *) calloc(ntups, sizeof(TableInfo));

      i_reltableoid = PQfnumber(res, "tableoid");
      i_reloid = PQfnumber(res, "oid");
--- 4218,4224 ----
       * only one, because we don't yet know which tables might be inheritance
       * ancestors of the target table.
       */
!     tblinfo = (TableInfo *) pg_calloc(ntups, sizeof(TableInfo));

      i_reltableoid = PQfnumber(res, "tableoid");
      i_reloid = PQfnumber(res, "oid");
*************** getTables(int *numTables)
*** 4263,4273 ****
          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.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].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);
--- 4264,4274 ----
          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 = 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 = 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);
*************** getTables(int *numTables)
*** 4280,4286 ****
          if (PQgetisnull(res, i, i_reloftype))
              tblinfo[i].reloftype = NULL;
          else
!             tblinfo[i].reloftype = strdup(PQgetvalue(res, i, i_reloftype));
          tblinfo[i].ncheck = atoi(PQgetvalue(res, i, i_relchecks));
          if (PQgetisnull(res, i, i_owning_tab))
          {
--- 4281,4287 ----
          if (PQgetisnull(res, i, i_reloftype))
              tblinfo[i].reloftype = NULL;
          else
!             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))
          {
*************** getTables(int *numTables)
*** 4292,4300 ****
              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));

          /* other fields were zeroed above */

--- 4293,4301 ----
              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 = 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 */

*************** getInherits(int *numInherits)
*** 4408,4414 ****

      *numInherits = ntups;

!     inhinfo = (InhInfo *) malloc(ntups * sizeof(InhInfo));

      i_inhrelid = PQfnumber(res, "inhrelid");
      i_inhparent = PQfnumber(res, "inhparent");
--- 4409,4415 ----

      *numInherits = ntups;

!     inhinfo = (InhInfo *) pg_malloc(ntups * sizeof(InhInfo));

      i_inhrelid = PQfnumber(res, "inhrelid");
      i_inhparent = PQfnumber(res, "inhparent");
*************** getIndexes(TableInfo tblinfo[], int numT
*** 4673,4680 ****
          i_tablespace = PQfnumber(res, "tablespace");
          i_options = PQfnumber(res, "options");

!         indxinfo = (IndxInfo *) malloc(ntups * sizeof(IndxInfo));
!         constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));

          for (j = 0; j < ntups; j++)
          {
--- 4674,4681 ----
          i_tablespace = PQfnumber(res, "tablespace");
          i_options = PQfnumber(res, "options");

!         indxinfo = (IndxInfo *) pg_malloc(ntups * sizeof(IndxInfo));
!         constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));

          for (j = 0; j < ntups; j++)
          {
*************** getIndexes(TableInfo tblinfo[], int numT
*** 4684,4696 ****
              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.namespace = tbinfo->dobj.namespace;
              indxinfo[j].indextable = tbinfo;
!             indxinfo[j].indexdef = 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));

              /*
               * In pre-7.4 releases, indkeys may contain more entries than
--- 4685,4697 ----
              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 = pg_strdup(PQgetvalue(res, j, i_indexname));
              indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
              indxinfo[j].indextable = tbinfo;
!             indxinfo[j].indexdef = pg_strdup(PQgetvalue(res, j, i_indexdef));
              indxinfo[j].indnkeys = atoi(PQgetvalue(res, j, i_indnkeys));
!             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
*************** getIndexes(TableInfo tblinfo[], int numT
*** 4701,4707 ****
               * have to allocate enough space to keep parseOidArray from
               * complaining.
               */
!             indxinfo[j].indkeys = (Oid *) 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');
--- 4702,4708 ----
               * have to allocate enough space to keep parseOidArray from
               * complaining.
               */
!             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');
*************** getIndexes(TableInfo tblinfo[], int numT
*** 4720,4732 ****
                  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.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));
                  else
                      constrinfo[j].condef = NULL;
                  constrinfo[j].confrelid = InvalidOid;
--- 4721,4733 ----
                  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 = 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 = pg_strdup(PQgetvalue(res, j, i_condef));
                  else
                      constrinfo[j].condef = NULL;
                  constrinfo[j].confrelid = InvalidOid;
*************** getConstraints(TableInfo tblinfo[], int
*** 4821,4827 ****
          i_confrelid = PQfnumber(res, "confrelid");
          i_condef = PQfnumber(res, "condef");

!         constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));

          for (j = 0; j < ntups; j++)
          {
--- 4822,4828 ----
          i_confrelid = PQfnumber(res, "confrelid");
          i_condef = PQfnumber(res, "condef");

!         constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));

          for (j = 0; j < ntups; j++)
          {
*************** getConstraints(TableInfo tblinfo[], int
*** 4829,4840 ****
              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.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].confrelid = atooid(PQgetvalue(res, j, i_confrelid));
              constrinfo[j].conindex = 0;
              constrinfo[j].condeferrable = false;
--- 4830,4841 ----
              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 = 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 = pg_strdup(PQgetvalue(res, j, i_condef));
              constrinfo[j].confrelid = atooid(PQgetvalue(res, j, i_confrelid));
              constrinfo[j].conindex = 0;
              constrinfo[j].condeferrable = false;
*************** getDomainConstraints(TypeInfo *tyinfo)
*** 4904,4910 ****
      i_conname = PQfnumber(res, "conname");
      i_consrc = PQfnumber(res, "consrc");

!     constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));

      tyinfo->nDomChecks = ntups;
      tyinfo->domChecks = constrinfo;
--- 4905,4911 ----
      i_conname = PQfnumber(res, "conname");
      i_consrc = PQfnumber(res, "consrc");

!     constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));

      tyinfo->nDomChecks = ntups;
      tyinfo->domChecks = constrinfo;
*************** getDomainConstraints(TypeInfo *tyinfo)
*** 4915,4926 ****
          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.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].confrelid = InvalidOid;
          constrinfo[i].conindex = 0;
          constrinfo[i].condeferrable = false;
--- 4916,4927 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_consrc));
          constrinfo[i].confrelid = InvalidOid;
          constrinfo[i].conindex = 0;
          constrinfo[i].condeferrable = false;
*************** getRules(int *numRules)
*** 5002,5008 ****

      *numRules = ntups;

!     ruleinfo = (RuleInfo *) malloc(ntups * sizeof(RuleInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 5003,5009 ----

      *numRules = ntups;

!     ruleinfo = (RuleInfo *) pg_malloc(ntups * sizeof(RuleInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getRules(int *numRules)
*** 5020,5026 ****
          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));
          ruletableoid = atooid(PQgetvalue(res, i, i_ruletable));
          ruleinfo[i].ruletable = findTableByOid(ruletableoid);
          if (ruleinfo[i].ruletable == NULL)
--- 5021,5027 ----
          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 = pg_strdup(PQgetvalue(res, i, i_rulename));
          ruletableoid = atooid(PQgetvalue(res, i, i_ruletable));
          ruleinfo[i].ruletable = findTableByOid(ruletableoid);
          if (ruleinfo[i].ruletable == NULL)
*************** getTriggers(TableInfo tblinfo[], int num
*** 5224,5230 ****
          i_tginitdeferred = PQfnumber(res, "tginitdeferred");
          i_tgdef = PQfnumber(res, "tgdef");

!         tginfo = (TriggerInfo *) malloc(ntups * sizeof(TriggerInfo));

          for (j = 0; j < ntups; j++)
          {
--- 5225,5231 ----
          i_tginitdeferred = PQfnumber(res, "tginitdeferred");
          i_tgdef = PQfnumber(res, "tgdef");

!         tginfo = (TriggerInfo *) pg_malloc(ntups * sizeof(TriggerInfo));

          for (j = 0; j < ntups; j++)
          {
*************** getTriggers(TableInfo tblinfo[], int num
*** 5232,5244 ****
              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.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));

                  /* remaining fields are not valid if we have tgdef */
                  tginfo[j].tgfname = NULL;
--- 5233,5245 ----
              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 = 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 = pg_strdup(PQgetvalue(res, j, i_tgdef));

                  /* remaining fields are not valid if we have tgdef */
                  tginfo[j].tgfname = NULL;
*************** getTriggers(TableInfo tblinfo[], int num
*** 5256,5272 ****
              {
                  tginfo[j].tgdef = NULL;

!                 tginfo[j].tgfname = 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].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].tgconstrrelid = atooid(PQgetvalue(res, j, i_tgconstrrelid));
                      if (OidIsValid(tginfo[j].tgconstrrelid))
                      {
--- 5257,5273 ----
              {
                  tginfo[j].tgdef = NULL;

!                 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 = 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 = pg_strdup(PQgetvalue(res, j, i_tgconstrname));
                      tginfo[j].tgconstrrelid = atooid(PQgetvalue(res, j, i_tgconstrrelid));
                      if (OidIsValid(tginfo[j].tgconstrrelid))
                      {
*************** getTriggers(TableInfo tblinfo[], int num
*** 5277,5283 ****
                                        tginfo[j].tgconstrrelid);
                              exit_nicely();
                          }
!                         tginfo[j].tgconstrrelname = strdup(PQgetvalue(res, j, i_tgconstrrelname));
                      }
                      else
                          tginfo[j].tgconstrrelname = NULL;
--- 5278,5284 ----
                                        tginfo[j].tgconstrrelid);
                              exit_nicely();
                          }
!                         tginfo[j].tgconstrrelname = pg_strdup(PQgetvalue(res, j, i_tgconstrrelname));
                      }
                      else
                          tginfo[j].tgconstrrelname = NULL;
*************** getProcLangs(int *numProcLangs)
*** 5394,5400 ****

      *numProcLangs = ntups;

!     planginfo = (ProcLangInfo *) malloc(ntups * sizeof(ProcLangInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 5395,5401 ----

      *numProcLangs = ntups;

!     planginfo = (ProcLangInfo *) pg_malloc(ntups * sizeof(ProcLangInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getProcLangs(int *numProcLangs)
*** 5414,5420 ****
          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].lanpltrusted = *(PQgetvalue(res, i, i_lanpltrusted)) == 't';
          planginfo[i].lanplcallfoid = atooid(PQgetvalue(res, i, i_lanplcallfoid));
          if (i_laninline >= 0)
--- 5415,5421 ----
          planginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
          AssignDumpId(&planginfo[i].dobj);

!         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)
*************** getProcLangs(int *numProcLangs)
*** 5426,5438 ****
          else
              planginfo[i].lanvalidator = InvalidOid;
          if (i_lanacl >= 0)
!             planginfo[i].lanacl = strdup(PQgetvalue(res, i, i_lanacl));
          else
!             planginfo[i].lanacl = strdup("{=U}");
          if (i_lanowner >= 0)
!             planginfo[i].lanowner = strdup(PQgetvalue(res, i, i_lanowner));
          else
!             planginfo[i].lanowner = strdup("");

          if (g_fout->remoteVersion < 70300)
          {
--- 5427,5439 ----
          else
              planginfo[i].lanvalidator = InvalidOid;
          if (i_lanacl >= 0)
!             planginfo[i].lanacl = pg_strdup(PQgetvalue(res, i, i_lanacl));
          else
!             planginfo[i].lanacl = pg_strdup("{=U}");
          if (i_lanowner >= 0)
!             planginfo[i].lanowner = pg_strdup(PQgetvalue(res, i, i_lanowner));
          else
!             planginfo[i].lanowner = pg_strdup("");

          if (g_fout->remoteVersion < 70300)
          {
*************** getCasts(int *numCasts)
*** 5515,5521 ****

      *numCasts = ntups;

!     castinfo = (CastInfo *) malloc(ntups * sizeof(CastInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 5516,5522 ----

      *numCasts = ntups;

!     castinfo = (CastInfo *) pg_malloc(ntups * sizeof(CastInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 5797,5820 ****
          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));
          hasdefaults = false;

          for (j = 0; j < ntups; j++)
--- 5798,5821 ----
          i_attfdwoptions = PQfnumber(res, "attfdwoptions");

          tbinfo->numatts = ntups;
!         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++)
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 5825,5832 ****
                            tbinfo->dobj.name);
                  exit_nicely();
              }
!             tbinfo->attnames[j] = strdup(PQgetvalue(res, j, i_attname));
!             tbinfo->atttypnames[j] = 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));
--- 5826,5833 ----
                            tbinfo->dobj.name);
                  exit_nicely();
              }
!             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));
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 5836,5844 ****
              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->attcollation[j] = atooid(PQgetvalue(res, j, i_attcollation));
!             tbinfo->attfdwoptions[j] = strdup(PQgetvalue(res, j, i_attfdwoptions));
              tbinfo->attrdefs[j] = NULL; /* fix below */
              if (PQgetvalue(res, j, i_atthasdef)[0] == 't')
                  hasdefaults = true;
--- 5837,5845 ----
              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] = pg_strdup(PQgetvalue(res, j, i_attoptions));
              tbinfo->attcollation[j] = atooid(PQgetvalue(res, j, i_attcollation));
!             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;
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 5902,5908 ****
              check_sql_result(res, g_conn, q->data, PGRES_TUPLES_OK);

              numDefaults = PQntuples(res);
!             attrdefs = (AttrDefInfo *) malloc(numDefaults * sizeof(AttrDefInfo));

              for (j = 0; j < numDefaults; j++)
              {
--- 5903,5909 ----
              check_sql_result(res, g_conn, q->data, PGRES_TUPLES_OK);

              numDefaults = PQntuples(res);
!             attrdefs = (AttrDefInfo *) pg_malloc(numDefaults * sizeof(AttrDefInfo));

              for (j = 0; j < numDefaults; j++)
              {
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 5914,5922 ****
                  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].dobj.name = strdup(tbinfo->dobj.name);
                  attrdefs[j].dobj.namespace = tbinfo->dobj.namespace;

                  attrdefs[j].dobj.dump = tbinfo->dobj.dump;
--- 5915,5923 ----
                  AssignDumpId(&attrdefs[j].dobj);
                  attrdefs[j].adtable = tbinfo;
                  attrdefs[j].adnum = adnum = atoi(PQgetvalue(res, j, 2));
!                 attrdefs[j].adef_expr = pg_strdup(PQgetvalue(res, j, 3));

!                 attrdefs[j].dobj.name = pg_strdup(tbinfo->dobj.name);
                  attrdefs[j].dobj.namespace = tbinfo->dobj.namespace;

                  attrdefs[j].dobj.dump = tbinfo->dobj.dump;
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 6050,6056 ****
                  exit_nicely();
              }

!             constrs = (ConstraintInfo *) malloc(numConstrs * sizeof(ConstraintInfo));
              tbinfo->checkexprs = constrs;

              for (j = 0; j < numConstrs; j++)
--- 6051,6057 ----
                  exit_nicely();
              }

!             constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(ConstraintInfo));
              tbinfo->checkexprs = constrs;

              for (j = 0; j < numConstrs; j++)
*************** getTableAttrs(TableInfo *tblinfo, int nu
*** 6059,6070 ****
                  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.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].confrelid = InvalidOid;
                  constrs[j].conindex = 0;
                  constrs[j].condeferrable = false;
--- 6060,6071 ----
                  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 = 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 = pg_strdup(PQgetvalue(res, j, 3));
                  constrs[j].confrelid = InvalidOid;
                  constrs[j].conindex = 0;
                  constrs[j].condeferrable = false;
*************** getTSParsers(int *numTSParsers)
*** 6148,6154 ****
      ntups = PQntuples(res);
      *numTSParsers = ntups;

!     prsinfo = (TSParserInfo *) malloc(ntups * sizeof(TSParserInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 6149,6155 ----
      ntups = PQntuples(res);
      *numTSParsers = ntups;

!     prsinfo = (TSParserInfo *) pg_malloc(ntups * sizeof(TSParserInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getTSParsers(int *numTSParsers)
*** 6166,6172 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_prsnamespace)),
                                                    prsinfo[i].dobj.catId.oid);
          prsinfo[i].prsstart = atooid(PQgetvalue(res, i, i_prsstart));
--- 6167,6173 ----
          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 = 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));
*************** getTSDictionaries(int *numTSDicts)
*** 6231,6237 ****
      ntups = PQntuples(res);
      *numTSDicts = ntups;

!     dictinfo = (TSDictInfo *) malloc(ntups * sizeof(TSDictInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 6232,6238 ----
      ntups = PQntuples(res);
      *numTSDicts = ntups;

!     dictinfo = (TSDictInfo *) pg_malloc(ntups * sizeof(TSDictInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getTSDictionaries(int *numTSDicts)
*** 6247,6261 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_dictnamespace)),
                                                   dictinfo[i].dobj.catId.oid);
!         dictinfo[i].rolname = 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));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(dictinfo[i].dobj));
--- 6248,6262 ----
          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 = 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 = 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 = pg_strdup(PQgetvalue(res, i, i_dictinitoption));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(dictinfo[i].dobj));
*************** getTSTemplates(int *numTSTemplates)
*** 6310,6316 ****
      ntups = PQntuples(res);
      *numTSTemplates = ntups;

!     tmplinfo = (TSTemplateInfo *) malloc(ntups * sizeof(TSTemplateInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 6311,6317 ----
      ntups = PQntuples(res);
      *numTSTemplates = ntups;

!     tmplinfo = (TSTemplateInfo *) pg_malloc(ntups * sizeof(TSTemplateInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getTSTemplates(int *numTSTemplates)
*** 6325,6331 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_tmplnamespace)),
                                                   tmplinfo[i].dobj.catId.oid);
          tmplinfo[i].tmplinit = atooid(PQgetvalue(res, i, i_tmplinit));
--- 6326,6332 ----
          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 = 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));
*************** getTSConfigurations(int *numTSConfigs)
*** 6385,6391 ****
      ntups = PQntuples(res);
      *numTSConfigs = ntups;

!     cfginfo = (TSConfigInfo *) malloc(ntups * sizeof(TSConfigInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 6386,6392 ----
      ntups = PQntuples(res);
      *numTSConfigs = ntups;

!     cfginfo = (TSConfigInfo *) pg_malloc(ntups * sizeof(TSConfigInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getTSConfigurations(int *numTSConfigs)
*** 6400,6409 ****
          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.namespace = findNamespace(atooid(PQgetvalue(res, i, i_cfgnamespace)),
                                                    cfginfo[i].dobj.catId.oid);
!         cfginfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
          cfginfo[i].cfgparser = atooid(PQgetvalue(res, i, i_cfgparser));

          /* Decide whether we want to dump it */
--- 6401,6410 ----
          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 = 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 = pg_strdup(PQgetvalue(res, i, i_rolname));
          cfginfo[i].cfgparser = atooid(PQgetvalue(res, i, i_cfgparser));

          /* Decide whether we want to dump it */
*************** getForeignDataWrappers(int *numForeignDa
*** 6484,6490 ****
      ntups = PQntuples(res);
      *numForeignDataWrappers = ntups;

!     fdwinfo = (FdwInfo *) malloc(ntups * sizeof(FdwInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 6485,6491 ----
      ntups = PQntuples(res);
      *numForeignDataWrappers = ntups;

!     fdwinfo = (FdwInfo *) pg_malloc(ntups * sizeof(FdwInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getForeignDataWrappers(int *numForeignDa
*** 6501,6513 ****
          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.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));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(fdwinfo[i].dobj));
--- 6502,6514 ----
          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 = pg_strdup(PQgetvalue(res, i, i_fdwname));
          fdwinfo[i].dobj.namespace = NULL;
!         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));
*************** getForeignServers(int *numForeignServers
*** 6571,6577 ****
      ntups = PQntuples(res);
      *numForeignServers = ntups;

!     srvinfo = (ForeignServerInfo *) malloc(ntups * sizeof(ForeignServerInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
--- 6572,6578 ----
      ntups = PQntuples(res);
      *numForeignServers = ntups;

!     srvinfo = (ForeignServerInfo *) pg_malloc(ntups * sizeof(ForeignServerInfo));

      i_tableoid = PQfnumber(res, "tableoid");
      i_oid = PQfnumber(res, "oid");
*************** getForeignServers(int *numForeignServers
*** 6589,6602 ****
          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.namespace = NULL;
!         srvinfo[i].rolname = 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));

          /* Decide whether we want to dump it */
          selectDumpableObject(&(srvinfo[i].dobj));
--- 6590,6603 ----
          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 = pg_strdup(PQgetvalue(res, i, i_srvname));
          srvinfo[i].dobj.namespace = NULL;
!         srvinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
          srvinfo[i].srvfdw = atooid(PQgetvalue(res, i, i_srvfdw));
!         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));
*************** getDefaultACLs(int *numDefaultACLs)
*** 6656,6662 ****
      ntups = PQntuples(res);
      *numDefaultACLs = ntups;

!     daclinfo = (DefaultACLInfo *) malloc(ntups * sizeof(DefaultACLInfo));

      i_oid = PQfnumber(res, "oid");
      i_tableoid = PQfnumber(res, "tableoid");
--- 6657,6663 ----
      ntups = PQntuples(res);
      *numDefaultACLs = ntups;

!     daclinfo = (DefaultACLInfo *) pg_malloc(ntups * sizeof(DefaultACLInfo));

      i_oid = PQfnumber(res, "oid");
      i_tableoid = PQfnumber(res, "tableoid");
*************** getDefaultACLs(int *numDefaultACLs)
*** 6674,6680 ****
          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));

          if (nspid != InvalidOid)
              daclinfo[i].dobj.namespace = findNamespace(nspid,
--- 6675,6681 ----
          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 = pg_strdup(PQgetvalue(res, i, i_defaclobjtype));

          if (nspid != InvalidOid)
              daclinfo[i].dobj.namespace = findNamespace(nspid,
*************** getDefaultACLs(int *numDefaultACLs)
*** 6682,6690 ****
          else
              daclinfo[i].dobj.namespace = NULL;

!         daclinfo[i].defaclrole = strdup(PQgetvalue(res, i, i_defaclrole));
          daclinfo[i].defaclobjtype = *(PQgetvalue(res, i, i_defaclobjtype));
!         daclinfo[i].defaclacl = strdup(PQgetvalue(res, i, i_defaclacl));

          /* Decide whether we want to dump it */
          selectDumpableDefaultACL(&(daclinfo[i]));
--- 6683,6691 ----
          else
              daclinfo[i].dobj.namespace = NULL;

!         daclinfo[i].defaclrole = pg_strdup(PQgetvalue(res, i, i_defaclrole));
          daclinfo[i].defaclobjtype = *(PQgetvalue(res, i, i_defaclobjtype));
!         daclinfo[i].defaclacl = pg_strdup(PQgetvalue(res, i, i_defaclacl));

          /* Decide whether we want to dump it */
          selectDumpableDefaultACL(&(daclinfo[i]));
*************** collectComments(Archive *fout, CommentIt
*** 7012,7018 ****

      ntups = PQntuples(res);

!     comments = (CommentItem *) malloc(ntups * sizeof(CommentItem));

      for (i = 0; i < ntups; i++)
      {
--- 7013,7019 ----

      ntups = PQntuples(res);

!     comments = (CommentItem *) pg_malloc(ntups * sizeof(CommentItem));

      for (i = 0; i < ntups; i++)
      {
*************** dumpNamespace(Archive *fout, NamespaceIn
*** 7165,7171 ****
      delq = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qnspname = strdup(fmtId(nspinfo->dobj.name));

      appendPQExpBuffer(delq, "DROP SCHEMA %s;\n", qnspname);

--- 7166,7172 ----
      delq = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qnspname = pg_strdup(fmtId(nspinfo->dobj.name));

      appendPQExpBuffer(delq, "DROP SCHEMA %s;\n", qnspname);

*************** dumpExtension(Archive *fout, ExtensionIn
*** 7224,7230 ****
      delq = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qextname = strdup(fmtId(extinfo->dobj.name));

      appendPQExpBuffer(delq, "DROP EXTENSION %s;\n", qextname);

--- 7225,7231 ----
      delq = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qextname = pg_strdup(fmtId(extinfo->dobj.name));

      appendPQExpBuffer(delq, "DROP EXTENSION %s;\n", qextname);

*************** dumpProcLang(Archive *fout, ProcLangInfo
*** 8641,8647 ****
      delqry = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qlanname = strdup(fmtId(plang->dobj.name));

      /*
       * If dumping a HANDLER clause, treat the language as being in the handler
--- 8642,8648 ----
      delqry = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qlanname = pg_strdup(fmtId(plang->dobj.name));

      /*
       * If dumping a HANDLER clause, treat the language as being in the handler
*************** convertRegProcReference(const char *proc
*** 9730,9736 ****
          char       *paren;
          bool        inquote;

!         name = strdup(proc);
          /* find non-double-quoted left paren */
          inquote = false;
          for (paren = name; *paren; paren++)
--- 9731,9737 ----
          char       *paren;
          bool        inquote;

!         name = pg_strdup(proc);
          /* find non-double-quoted left paren */
          inquote = false;
          for (paren = name; *paren; paren++)
*************** convertOperatorReference(const char *opr
*** 9777,9783 ****
          bool        inquote;
          bool        sawdot;

!         name = strdup(opr);
          /* find non-double-quoted left paren, and check for non-quoted dot */
          inquote = false;
          sawdot = false;
--- 9778,9784 ----
          bool        inquote;
          bool        sawdot;

!         name = pg_strdup(opr);
          /* find non-double-quoted left paren, and check for non-quoted dot */
          inquote = false;
          sawdot = false;
*************** convertOperatorReference(const char *opr
*** 9796,9802 ****
          /* If not schema-qualified, don't need to add OPERATOR() */
          if (!sawdot)
              return name;
!         oname = malloc(strlen(name) + 11);
          sprintf(oname, "OPERATOR(%s)", name);
          free(name);
          return oname;
--- 9797,9803 ----
          /* If not schema-qualified, don't need to add OPERATOR() */
          if (!sawdot)
              return name;
!         oname = pg_malloc(strlen(name) + 11);
          sprintf(oname, "OPERATOR(%s)", name);
          free(name);
          return oname;
*************** convertTSFunction(Oid funcOid)
*** 9843,9849 ****
          exit_nicely();
      }

!     result = strdup(PQgetvalue(res, 0, 0));

      PQclear(res);

--- 9844,9850 ----
          exit_nicely();
      }

!     result = pg_strdup(PQgetvalue(res, 0, 0));

      PQclear(res);

*************** dumpOpclass(Archive *fout, OpclassInfo *
*** 9969,9979 ****
      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));
      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));

      /*
       * DROP must be fully qualified in case same name appears in pg_catalog
--- 9970,9980 ----
      opckeytype = PQgetvalue(res, 0, i_opckeytype);
      opcdefault = PQgetvalue(res, 0, i_opcdefault);
      /* opcfamily will still be needed after we PQclear res */
!     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 = pg_strdup(PQgetvalue(res, 0, i_amname));

      /*
       * DROP must be fully qualified in case same name appears in pg_catalog
*************** dumpOpfamily(Archive *fout, OpfamilyInfo
*** 10416,10422 ****
      i_amname = PQfnumber(res, "amname");

      /* amname will still be needed after we PQclear res */
!     amname = strdup(PQgetvalue(res, 0, i_amname));

      /*
       * DROP must be fully qualified in case same name appears in pg_catalog
--- 10417,10423 ----
      i_amname = PQfnumber(res, "amname");

      /* amname will still be needed after we PQclear res */
!     amname = pg_strdup(PQgetvalue(res, 0, i_amname));

      /*
       * DROP must be fully qualified in case same name appears in pg_catalog
*************** dumpForeignDataWrapper(Archive *fout, Fd
*** 11436,11442 ****
      delq = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qfdwname = strdup(fmtId(fdwinfo->dobj.name));

      appendPQExpBuffer(q, "CREATE FOREIGN DATA WRAPPER %s",
                        qfdwname);
--- 11437,11443 ----
      delq = createPQExpBuffer();
      labelq = createPQExpBuffer();

!     qfdwname = pg_strdup(fmtId(fdwinfo->dobj.name));

      appendPQExpBuffer(q, "CREATE FOREIGN DATA WRAPPER %s",
                        qfdwname);
*************** dumpForeignServer(Archive *fout, Foreign
*** 11515,11521 ****
      labelq = createPQExpBuffer();
      query = createPQExpBuffer();

!     qsrvname = strdup(fmtId(srvinfo->dobj.name));

      /* look up the foreign-data wrapper */
      selectSourceSchema("pg_catalog");
--- 11516,11522 ----
      labelq = createPQExpBuffer();
      query = createPQExpBuffer();

!     qsrvname = pg_strdup(fmtId(srvinfo->dobj.name));

      /* look up the foreign-data wrapper */
      selectSourceSchema("pg_catalog");
*************** collectSecLabels(Archive *fout, SecLabel
*** 12098,12104 ****

      ntups = PQntuples(res);

!     labels = (SecLabelItem *) malloc(ntups * sizeof(SecLabelItem));

      for (i = 0; i < ntups; i++)
      {
--- 12099,12105 ----

      ntups = PQntuples(res);

!     labels = (SecLabelItem *) pg_malloc(ntups * sizeof(SecLabelItem));

      for (i = 0; i < ntups; i++)
      {
*************** dumpTable(Archive *fout, TableInfo *tbin
*** 12133,12139 ****
              dumpTableSchema(fout, tbinfo);

          /* Handle the ACL here */
!         namecopy = strdup(fmtId(tbinfo->dobj.name));
          dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
                  (tbinfo->relkind == RELKIND_SEQUENCE) ? "SEQUENCE" :
                  "TABLE",
--- 12134,12140 ----
              dumpTableSchema(fout, tbinfo);

          /* Handle the ACL here */
!         namecopy = pg_strdup(fmtId(tbinfo->dobj.name));
          dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
                  (tbinfo->relkind == RELKIND_SEQUENCE) ? "SEQUENCE" :
                  "TABLE",
*************** dumpTable(Archive *fout, TableInfo *tbin
*** 12167,12174 ****
                  char       *attnamecopy;
                  char       *acltag;

!                 attnamecopy = strdup(fmtId(attname));
!                 acltag = 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",
--- 12168,12175 ----
                  char       *attnamecopy;
                  char       *acltag;

!                 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",
*************** dumpTableSchema(Archive *fout, TableInfo
*** 12303,12310 ****
              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));
              PQclear(res);
          }
          else
--- 12304,12311 ----
              check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
              i_srvname = PQfnumber(res, "srvname");
              i_ftoptions = PQfnumber(res, "ftoptions");
!             srvname = pg_strdup(PQgetvalue(res, 0, i_srvname));
!             ftoptions = pg_strdup(PQgetvalue(res, 0, i_ftoptions));
              PQclear(res);
          }
          else
*************** getExtensionMembership(ExtensionInfo ext
*** 13975,13981 ****
                       */
                      makeTableDataInfo(configtbl, false);
                      if (strlen(extconditionarray[j]) > 0)
!                         configtbl->dataObj->filtercond = strdup(extconditionarray[j]);
                  }
              }
          }
--- 13976,13982 ----
                       */
                      makeTableDataInfo(configtbl, false);
                      if (strlen(extconditionarray[j]) > 0)
!                         configtbl->dataObj->filtercond = pg_strdup(extconditionarray[j]);
                  }
              }
          }
*************** selectSourceSchema(const char *schemaNam
*** 14148,14154 ****
      destroyPQExpBuffer(query);
      if (curSchemaName)
          free(curSchemaName);
!     curSchemaName = strdup(schemaName);
  }

  /*
--- 14149,14155 ----
      destroyPQExpBuffer(query);
      if (curSchemaName)
          free(curSchemaName);
!     curSchemaName = pg_strdup(schemaName);
  }

  /*
*************** getFormattedTypeName(Oid oid, OidOptions
*** 14169,14181 ****
      if (oid == 0)
      {
          if ((opts & zeroAsOpaque) != 0)
!             return strdup(g_opaque_type);
          else if ((opts & zeroAsAny) != 0)
!             return strdup("'any'");
          else if ((opts & zeroAsStar) != 0)
!             return strdup("*");
          else if ((opts & zeroAsNone) != 0)
!             return strdup("NONE");
      }

      query = createPQExpBuffer();
--- 14170,14182 ----
      if (oid == 0)
      {
          if ((opts & zeroAsOpaque) != 0)
!             return pg_strdup(g_opaque_type);
          else if ((opts & zeroAsAny) != 0)
!             return pg_strdup("'any'");
          else if ((opts & zeroAsStar) != 0)
!             return pg_strdup("*");
          else if ((opts & zeroAsNone) != 0)
!             return pg_strdup("NONE");
      }

      query = createPQExpBuffer();
*************** getFormattedTypeName(Oid oid, OidOptions
*** 14214,14225 ****
      if (g_fout->remoteVersion >= 70100)
      {
          /* already quoted */
!         result = strdup(PQgetvalue(res, 0, 0));
      }
      else
      {
          /* may need to quote it */
!         result = strdup(fmtId(PQgetvalue(res, 0, 0)));
      }

      PQclear(res);
--- 14215,14226 ----
      if (g_fout->remoteVersion >= 70100)
      {
          /* already quoted */
!         result = pg_strdup(PQgetvalue(res, 0, 0));
      }
      else
      {
          /* may need to quote it */
!         result = pg_strdup(fmtId(PQgetvalue(res, 0, 0)));
      }

      PQclear(res);
*************** myFormatType(const char *typname, int32
*** 14292,14298 ****
      if (isarray)
          appendPQExpBuffer(buf, "[]");

!     result = strdup(buf->data);
      destroyPQExpBuffer(buf);

      return result;
--- 14293,14299 ----
      if (isarray)
          appendPQExpBuffer(buf, "[]");

!     result = pg_strdup(buf->data);
      destroyPQExpBuffer(buf);

      return result;
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
new file mode 100644
index 3d5d534..c248e75
*** a/src/bin/pg_dump/pg_dump.h
--- b/src/bin/pg_dump/pg_dump.h
*************** extern void simple_string_list_append(Si
*** 521,531 ****
  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);

--- 521,526 ----
diff --git a/src/bin/pg_dump/pg_dump_sort.c b/src/bin/pg_dump/pg_dump_sort.c
new file mode 100644
index efde0d0..f60ee70
*** a/src/bin/pg_dump/pg_dump_sort.c
--- b/src/bin/pg_dump/pg_dump_sort.c
***************
*** 14,20 ****
   *-------------------------------------------------------------------------
   */
  #include "pg_backup_archiver.h"
!

  static const char *modulename = gettext_noop("sorter");

--- 14,20 ----
   *-------------------------------------------------------------------------
   */
  #include "pg_backup_archiver.h"
! #include "common.h"

  static const char *modulename = gettext_noop("sorter");

*************** sortDumpableObjects(DumpableObject **obj
*** 227,236 ****
      if (numObjs <= 0)
          return;

!     ordering = (DumpableObject **) malloc(numObjs * sizeof(DumpableObject *));
!     if (ordering == NULL)
!         exit_horribly(NULL, modulename, "out of memory\n");
!
      while (!TopoSort(objs, numObjs, ordering, &nOrdering))
          findDependencyLoops(ordering, nOrdering, numObjs);

--- 227,233 ----
      if (numObjs <= 0)
          return;

!     ordering = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *));
      while (!TopoSort(objs, numObjs, ordering, &nOrdering))
          findDependencyLoops(ordering, nOrdering, numObjs);

*************** TopoSort(DumpableObject **objs,
*** 301,309 ****
          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");

      /*
       * Scan the constraints, and for each item in the input, generate a count
--- 298,304 ----
          return true;

      /* Create workspace for the above-described heap */
!     pendingHeap = (int *) pg_malloc(numObjs * sizeof(int));

      /*
       * Scan the constraints, and for each item in the input, generate a count
*************** TopoSort(DumpableObject **objs,
*** 312,324 ****
       * 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");
      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");
      for (i = 0; i < numObjs; i++)
      {
          obj = objs[i];
--- 307,315 ----
       * We also make a map showing the input-order index of the item with
       * dumpId j.
       */
!     beforeConstraints = (int *) pg_malloc((maxDumpId + 1) * sizeof(int));
      memset(beforeConstraints, 0, (maxDumpId + 1) * sizeof(int));
!     idMap = (int *) pg_malloc((maxDumpId + 1) * sizeof(int));
      for (i = 0; i < numObjs; i++)
      {
          obj = objs[i];
*************** findDependencyLoops(DumpableObject **obj
*** 516,524 ****
      bool        fixedloop;
      int            i;

!     workspace = (DumpableObject **) malloc(totObjs * sizeof(DumpableObject *));
!     if (workspace == NULL)
!         exit_horribly(NULL, modulename, "out of memory\n");
      initiallen = 0;
      fixedloop = false;

--- 507,513 ----
      bool        fixedloop;
      int            i;

!     workspace = (DumpableObject **) pg_malloc(totObjs * sizeof(DumpableObject *));
      initiallen = 0;
      fixedloop = false;

diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c
new file mode 100644
index d138da5..4782e68
*** a/src/bin/pg_dump/pg_dumpall.c
--- b/src/bin/pg_dump/pg_dumpall.c
*************** static PGconn *connectDatabase(const cha
*** 60,65 ****
--- 60,68 ----
  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;
*************** dumpGroups(PGconn *conn)
*** 916,922 ****
          if (strlen(grolist) < 3)
              continue;

!         grolist = strdup(grolist);
          grolist[0] = '(';
          grolist[strlen(grolist) - 1] = ')';
          printfPQExpBuffer(buf,
--- 919,925 ----
          if (strlen(grolist) < 3)
              continue;

!         grolist = pg_strdup(grolist);
          grolist[0] = '(';
          grolist[strlen(grolist) - 1] = ')';
          printfPQExpBuffer(buf,
*************** dumpTablespaces(PGconn *conn)
*** 1040,1046 ****
          char       *fspcname;

          /* needed for buildACLCommands() */
!         fspcname = strdup(fmtId(spcname));

          appendPQExpBuffer(buf, "CREATE TABLESPACE %s", fspcname);
          appendPQExpBuffer(buf, " OWNER %s", fmtId(spcowner));
--- 1043,1049 ----
          char       *fspcname;

          /* needed for buildACLCommands() */
!         fspcname = pg_strdup(fmtId(spcname));

          appendPQExpBuffer(buf, "CREATE TABLESPACE %s", fspcname);
          appendPQExpBuffer(buf, " OWNER %s", fmtId(spcowner));
*************** dumpCreateDB(PGconn *conn)
*** 1189,1199 ****
      if (PQntuples(res) > 0)
      {
          if (!PQgetisnull(res, 0, 0))
!             default_encoding = strdup(PQgetvalue(res, 0, 0));
          if (!PQgetisnull(res, 0, 1))
!             default_collate = strdup(PQgetvalue(res, 0, 1));
          if (!PQgetisnull(res, 0, 2))
!             default_ctype = strdup(PQgetvalue(res, 0, 2));
      }

      PQclear(res);
--- 1192,1202 ----
      if (PQntuples(res) > 0)
      {
          if (!PQgetisnull(res, 0, 0))
!             default_encoding = pg_strdup(PQgetvalue(res, 0, 0));
          if (!PQgetisnull(res, 0, 1))
!             default_collate = pg_strdup(PQgetvalue(res, 0, 1));
          if (!PQgetisnull(res, 0, 2))
!             default_ctype = pg_strdup(PQgetvalue(res, 0, 2));
      }

      PQclear(res);
*************** dumpCreateDB(PGconn *conn)
*** 1283,1289 ****
          char       *dbtablespace = PQgetvalue(res, i, 9);
          char       *fdbname;

!         fdbname = strdup(fmtId(dbname));

          resetPQExpBuffer(buf);

--- 1286,1292 ----
          char       *dbtablespace = PQgetvalue(res, i, 9);
          char       *fdbname;

!         fdbname = pg_strdup(fmtId(dbname));

          resetPQExpBuffer(buf);

*************** makeAlterConfigCommand(PGconn *conn, con
*** 1519,1525 ****
      char       *mine;
      PQExpBuffer buf = createPQExpBuffer();

!     mine = strdup(arrayitem);
      pos = strchr(mine, '=');
      if (pos == NULL)
          return;
--- 1522,1528 ----
      char       *mine;
      PQExpBuffer buf = createPQExpBuffer();

!     mine = pg_strdup(arrayitem);
      pos = strchr(mine, '=');
      if (pos == NULL)
          return;
*************** connectDatabase(const char *dbname, cons
*** 1688,1701 ****
      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);
!         }

          keywords[0] = "host";
          values[0] = pghost;
--- 1691,1698 ----
      do
      {
  #define PARAMS_ARRAY_SIZE    7
!         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;
*************** doShellQuoting(PQExpBuffer buf, const ch
*** 1911,1913 ****
--- 1908,1948 ----
      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;
+ }
diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c
new file mode 100644
index 7731d25..a810ed6
*** a/src/bin/pg_dump/pg_restore.c
--- b/src/bin/pg_dump/pg_restore.c
***************
*** 39,44 ****
--- 39,45 ----
   *-------------------------------------------------------------------------
   */

+ #include "common.h"
  #include "pg_backup_archiver.h"
  #include "dumputils.h"

*************** main(int argc, char **argv)
*** 159,179 ****
                  opts->createDB = 1;
                  break;
              case 'd':
!                 opts->dbname = strdup(optarg);
                  break;
              case 'e':
                  opts->exit_on_error = true;
                  break;
              case 'f':            /* output file name */
!                 opts->filename = strdup(optarg);
                  break;
              case 'F':
                  if (strlen(optarg) != 0)
!                     opts->formatName = strdup(optarg);
                  break;
              case 'h':
                  if (strlen(optarg) != 0)
!                     opts->pghost = strdup(optarg);
                  break;
              case 'i':
                  /* ignored, deprecated option */
--- 160,180 ----
                  opts->createDB = 1;
                  break;
              case 'd':
!                 opts->dbname = pg_strdup(optarg);
                  break;
              case 'e':
                  opts->exit_on_error = true;
                  break;
              case 'f':            /* output file name */
!                 opts->filename = pg_strdup(optarg);
                  break;
              case 'F':
                  if (strlen(optarg) != 0)
!                     opts->formatName = pg_strdup(optarg);
                  break;
              case 'h':
                  if (strlen(optarg) != 0)
!                     opts->pghost = pg_strdup(optarg);
                  break;
              case 'i':
                  /* ignored, deprecated option */
*************** main(int argc, char **argv)
*** 188,198 ****
                  break;

              case 'L':            /* input TOC summary file name */
!                 opts->tocFile = strdup(optarg);
                  break;

              case 'n':            /* Dump data for this schema only */
!                 opts->schemaNames = strdup(optarg);
                  break;

              case 'O':
--- 189,199 ----
                  break;

              case 'L':            /* input TOC summary file name */
!                 opts->tocFile = pg_strdup(optarg);
                  break;

              case 'n':            /* Dump data for this schema only */
!                 opts->schemaNames = pg_strdup(optarg);
                  break;

              case 'O':
*************** main(int argc, char **argv)
*** 201,207 ****

              case 'p':
                  if (strlen(optarg) != 0)
!                     opts->pgport = strdup(optarg);
                  break;
              case 'R':
                  /* no-op, still accepted for backwards compatibility */
--- 202,208 ----

              case 'p':
                  if (strlen(optarg) != 0)
!                     opts->pgport = pg_strdup(optarg);
                  break;
              case 'R':
                  /* no-op, still accepted for backwards compatibility */
*************** main(int argc, char **argv)
*** 209,237 ****
              case 'P':            /* Function */
                  opts->selTypes = 1;
                  opts->selFunction = 1;
!                 opts->functionNames = strdup(optarg);
                  break;
              case 'I':            /* Index */
                  opts->selTypes = 1;
                  opts->selIndex = 1;
!                 opts->indexNames = strdup(optarg);
                  break;
              case 'T':            /* Trigger */
                  opts->selTypes = 1;
                  opts->selTrigger = 1;
!                 opts->triggerNames = strdup(optarg);
                  break;
              case 's':            /* dump schema only */
                  opts->schemaOnly = 1;
                  break;
              case 'S':            /* Superuser username */
                  if (strlen(optarg) != 0)
!                     opts->superuser = strdup(optarg);
                  break;
              case 't':            /* Dump data for this table only */
                  opts->selTypes = 1;
                  opts->selTable = 1;
!                 opts->tableNames = strdup(optarg);
                  break;

              case 'U':
--- 210,238 ----
              case 'P':            /* Function */
                  opts->selTypes = 1;
                  opts->selFunction = 1;
!                 opts->functionNames = pg_strdup(optarg);
                  break;
              case 'I':            /* Index */
                  opts->selTypes = 1;
                  opts->selIndex = 1;
!                 opts->indexNames = pg_strdup(optarg);
                  break;
              case 'T':            /* Trigger */
                  opts->selTypes = 1;
                  opts->selTrigger = 1;
!                 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 = pg_strdup(optarg);
                  break;
              case 't':            /* Dump data for this table only */
                  opts->selTypes = 1;
                  opts->selTable = 1;
!                 opts->tableNames = pg_strdup(optarg);
                  break;

              case 'U':

pgsql-hackers by date:

Previous
From: Ross Reedstrom
Date:
Subject: Re: proposal: psql concise mode
Next
From: Ross Reedstrom
Date:
Subject: Re: feature request: auto savepoint for interactive psql when in transaction.