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.o kwlookup.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.o kwlookup.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 - #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 /* * 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 + + #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 + #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 *************** 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 *************** _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 #include *************** 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 /* 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 #include *************** 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':