PostgreSQL Source Code  git master
common.c File Reference
#include "postgres_fe.h"
#include <ctype.h>
#include "catalog/pg_class_d.h"
#include "fe_utils/string_utils.h"
#include "pg_backup_archiver.h"
#include "pg_backup_utils.h"
#include "pg_dump.h"
Include dependency graph for common.c:

Go to the source code of this file.

Functions

static void flagInhTables (Archive *fout, TableInfo *tbinfo, int numTables, InhInfo *inhinfo, int numInherits)
 
static void flagInhIndexes (Archive *fout, TableInfo *tblinfo, int numTables)
 
static void flagInhAttrs (DumpOptions *dopt, TableInfo *tblinfo, int numTables)
 
static DumpableObject ** buildIndexArray (void *objArray, int numObjs, Size objSize)
 
static int DOCatalogIdCompare (const void *p1, const void *p2)
 
static int ExtensionMemberIdCompare (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)
 
static IndxInfofindIndexByOid (Oid oid, DumpableObject **idxinfoindex, int numIndexes)
 
TableInfogetSchemaData (Archive *fout, int *numTablesPtr)
 
static void flagInhIndexes (Archive *fout, TableInfo tblinfo[], int numTables)
 
void AssignDumpId (DumpableObject *dobj)
 
DumpId createDumpId (void)
 
DumpId getMaxDumpId (void)
 
DumpableObjectfindObjectByDumpId (DumpId dumpId)
 
DumpableObjectfindObjectByCatalogId (CatalogId catalogId)
 
static DumpableObjectfindObjectByOid (Oid oid, DumpableObject **indexArray, int numObjs)
 
void getDumpableObjects (DumpableObject ***objs, int *numObjs)
 
void addObjectDependency (DumpableObject *dobj, DumpId refId)
 
void removeObjectDependency (DumpableObject *dobj, DumpId refId)
 
TableInfofindTableByOid (Oid oid)
 
TypeInfofindTypeByOid (Oid oid)
 
FuncInfofindFuncByOid (Oid oid)
 
OprInfofindOprByOid (Oid oid)
 
CollInfofindCollationByOid (Oid oid)
 
NamespaceInfofindNamespaceByOid (Oid oid)
 
ExtensionInfofindExtensionByOid (Oid oid)
 
void setExtensionMembership (ExtensionMemberId *extmems, int nextmems)
 
ExtensionInfofindOwningExtension (CatalogId catalogId)
 
void parseOidArray (const char *str, Oid *array, int arraysize)
 

Variables

static DumpableObject ** dumpIdMap = NULL
 
static int allocedDumpIds = 0
 
static DumpId lastDumpId = 0
 
static bool catalogIdMapValid = false
 
static DumpableObject ** catalogIdMap = NULL
 
static int numCatalogIds = 0
 
static DumpableObject ** tblinfoindex
 
static DumpableObject ** typinfoindex
 
static DumpableObject ** funinfoindex
 
static DumpableObject ** oprinfoindex
 
static DumpableObject ** collinfoindex
 
static DumpableObject ** nspinfoindex
 
static DumpableObject ** extinfoindex
 
static int numTables
 
static int numTypes
 
static int numFuncs
 
static int numOperators
 
static int numCollations
 
static int numNamespaces
 
static int numExtensions
 
static ExtensionMemberIdextmembers
 
static int numextmembers
 

Function Documentation

◆ addObjectDependency()

void addObjectDependency ( DumpableObject dobj,
DumpId  refId 
)

Definition at line 781 of file common.c.

References _dumpableObject::allocDeps, _dumpableObject::dependencies, _dumpableObject::nDeps, pg_malloc(), and pg_realloc().

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

782 {
783  if (dobj->nDeps >= dobj->allocDeps)
784  {
785  if (dobj->allocDeps <= 0)
786  {
787  dobj->allocDeps = 16;
788  dobj->dependencies = (DumpId *)
789  pg_malloc(dobj->allocDeps * sizeof(DumpId));
790  }
791  else
792  {
793  dobj->allocDeps *= 2;
794  dobj->dependencies = (DumpId *)
795  pg_realloc(dobj->dependencies,
796  dobj->allocDeps * sizeof(DumpId));
797  }
798  }
799  dobj->dependencies[dobj->nDeps++] = refId;
800 }
int DumpId
Definition: pg_backup.h:234
DumpId * dependencies
Definition: pg_dump.h:135
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
void * pg_realloc(void *ptr, size_t size)
Definition: fe_memutils.c:65

◆ AssignDumpId()

void AssignDumpId ( DumpableObject dobj)

Definition at line 545 of file common.c.

References _dumpableObject::allocDeps, allocedDumpIds, catalogIdMapValid, _dumpableObject::dependencies, _dumpableObject::dump, DUMP_COMPONENT_ALL, _dumpableObject::dumpId, _dumpableObject::ext_member, lastDumpId, _dumpableObject::name, _dumpableObject::nDeps, pg_malloc(), and pg_realloc().

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

546 {
547  dobj->dumpId = ++lastDumpId;
548  dobj->name = NULL; /* must be set later */
549  dobj->namespace = NULL; /* may be set later */
550  dobj->dump = DUMP_COMPONENT_ALL; /* default assumption */
551  dobj->ext_member = false; /* default assumption */
552  dobj->dependencies = NULL;
553  dobj->nDeps = 0;
554  dobj->allocDeps = 0;
555 
556  while (dobj->dumpId >= allocedDumpIds)
557  {
558  int newAlloc;
559 
560  if (allocedDumpIds <= 0)
561  {
562  newAlloc = 256;
564  pg_malloc(newAlloc * sizeof(DumpableObject *));
565  }
566  else
567  {
568  newAlloc = allocedDumpIds * 2;
570  pg_realloc(dumpIdMap, newAlloc * sizeof(DumpableObject *));
571  }
572  memset(dumpIdMap + allocedDumpIds, 0,
573  (newAlloc - allocedDumpIds) * sizeof(DumpableObject *));
574  allocedDumpIds = newAlloc;
575  }
576  dumpIdMap[dobj->dumpId] = dobj;
577 
578  /* mark catalogIdMap invalid, but don't rebuild it yet */
579  catalogIdMapValid = false;
580 }
char * name
Definition: pg_dump.h:130
static int allocedDumpIds
Definition: common.c:30
DumpComponents dump
Definition: pg_dump.h:131
static DumpId lastDumpId
Definition: common.c:31
static DumpableObject ** dumpIdMap
Definition: common.c:29
DumpId * dependencies
Definition: pg_dump.h:135
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
DumpId dumpId
Definition: pg_dump.h:129
bool ext_member
Definition: pg_dump.h:134
void * pg_realloc(void *ptr, size_t size)
Definition: fe_memutils.c:65
static bool catalogIdMapValid
Definition: common.c:36
#define DUMP_COMPONENT_ALL
Definition: pg_dump.h:96

◆ buildIndexArray()

static DumpableObject ** buildIndexArray ( void *  objArray,
int  numObjs,
Size  objSize 
)
static

Definition at line 716 of file common.c.

References DOCatalogIdCompare(), i, pg_malloc(), and qsort.

Referenced by flagInhIndexes(), and getSchemaData().

717 {
718  DumpableObject **ptrs;
719  int i;
720 
721  ptrs = (DumpableObject **) pg_malloc(numObjs * sizeof(DumpableObject *));
722  for (i = 0; i < numObjs; i++)
723  ptrs[i] = (DumpableObject *) ((char *) objArray + i * objSize);
724 
725  /* We can use DOCatalogIdCompare to sort since its first key is OID */
726  if (numObjs > 1)
727  qsort((void *) ptrs, numObjs, sizeof(DumpableObject *),
729 
730  return ptrs;
731 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
static int DOCatalogIdCompare(const void *p1, const void *p2)
Definition: common.c:737
int i
#define qsort(a, b, c, d)
Definition: port.h:488

◆ createDumpId()

◆ DOCatalogIdCompare()

static int DOCatalogIdCompare ( const void *  p1,
const void *  p2 
)
static

Definition at line 737 of file common.c.

References _dumpableObject::catId, CatalogId::oid, oidcmp, and CatalogId::tableoid.

Referenced by buildIndexArray(), and findObjectByCatalogId().

738 {
739  const DumpableObject *obj1 = *(DumpableObject *const *) p1;
740  const DumpableObject *obj2 = *(DumpableObject *const *) p2;
741  int cmpval;
742 
743  /*
744  * Compare OID first since it's usually unique, whereas there will only be
745  * a few distinct values of tableoid.
746  */
747  cmpval = oidcmp(obj1->catId.oid, obj2->catId.oid);
748  if (cmpval == 0)
749  cmpval = oidcmp(obj1->catId.tableoid, obj2->catId.tableoid);
750  return cmpval;
751 }
Oid tableoid
Definition: pg_backup.h:230
#define oidcmp(x, y)
Definition: pg_dump.h:20
CatalogId catId
Definition: pg_dump.h:128

◆ ExtensionMemberIdCompare()

static int ExtensionMemberIdCompare ( const void *  p1,
const void *  p2 
)
static

Definition at line 971 of file common.c.

References _extensionMemberId::catId, CatalogId::oid, oidcmp, and CatalogId::tableoid.

Referenced by setExtensionMembership().

972 {
973  const ExtensionMemberId *obj1 = (const ExtensionMemberId *) p1;
974  const ExtensionMemberId *obj2 = (const ExtensionMemberId *) p2;
975  int cmpval;
976 
977  /*
978  * Compare OID first since it's usually unique, whereas there will only be
979  * a few distinct values of tableoid.
980  */
981  cmpval = oidcmp(obj1->catId.oid, obj2->catId.oid);
982  if (cmpval == 0)
983  cmpval = oidcmp(obj1->catId.tableoid, obj2->catId.tableoid);
984  return cmpval;
985 }
Oid tableoid
Definition: pg_backup.h:230
#define oidcmp(x, y)
Definition: pg_dump.h:20
CatalogId catId
Definition: pg_dump.h:635

◆ findCollationByOid()

CollInfo* findCollationByOid ( Oid  oid)

Definition at line 872 of file common.c.

References findObjectByOid(), and numCollations.

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

873 {
875 }
static DumpableObject ** collinfoindex
Definition: common.c:52
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static int numCollations
Definition: common.c:59

◆ findExtensionByOid()

ExtensionInfo* findExtensionByOid ( Oid  oid)

Definition at line 894 of file common.c.

References findObjectByOid(), and numExtensions.

Referenced by getExtensionMembership().

895 {
897 }
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static int numExtensions
Definition: common.c:61
static DumpableObject ** extinfoindex
Definition: common.c:54

◆ findFuncByOid()

FuncInfo* findFuncByOid ( Oid  oid)

Definition at line 850 of file common.c.

References findObjectByOid(), and numFuncs.

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

851 {
852  return (FuncInfo *) findObjectByOid(oid, funinfoindex, numFuncs);
853 }
static int numFuncs
Definition: common.c:57
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static DumpableObject ** funinfoindex
Definition: common.c:50

◆ findIndexByOid()

static IndxInfo * findIndexByOid ( Oid  oid,
DumpableObject **  idxinfoindex,
int  numIndexes 
)
static

Definition at line 907 of file common.c.

References findObjectByOid().

Referenced by flagInhIndexes().

908 {
909  return (IndxInfo *) findObjectByOid(oid, idxinfoindex, numIndexes);
910 }
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678

◆ findNamespaceByOid()

NamespaceInfo* findNamespaceByOid ( Oid  oid)

Definition at line 883 of file common.c.

References findObjectByOid(), and numNamespaces.

Referenced by findNamespace().

884 {
886 }
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static int numNamespaces
Definition: common.c:60
static DumpableObject ** nspinfoindex
Definition: common.c:53

◆ findObjectByCatalogId()

DumpableObject* findObjectByCatalogId ( CatalogId  catalogId)

Definition at line 627 of file common.c.

References catalogIdMap, catalogIdMapValid, difference(), DOCatalogIdCompare(), free, getDumpableObjects(), numCatalogIds, CatalogId::oid, oidcmp, qsort, and CatalogId::tableoid.

Referenced by buildMatViewRefreshDependencies(), and getDependencies().

628 {
629  DumpableObject **low;
630  DumpableObject **high;
631 
632  if (!catalogIdMapValid)
633  {
634  if (catalogIdMap)
637  if (numCatalogIds > 1)
638  qsort((void *) catalogIdMap, numCatalogIds,
640  catalogIdMapValid = true;
641  }
642 
643  /*
644  * We could use bsearch() here, but the notational cruft of calling
645  * bsearch is nearly as bad as doing it ourselves; and the generalized
646  * bsearch function is noticeably slower as well.
647  */
648  if (numCatalogIds <= 0)
649  return NULL;
650  low = catalogIdMap;
651  high = catalogIdMap + (numCatalogIds - 1);
652  while (low <= high)
653  {
654  DumpableObject **middle;
655  int difference;
656 
657  middle = low + (high - low) / 2;
658  /* comparison must match DOCatalogIdCompare, below */
659  difference = oidcmp((*middle)->catId.oid, catalogId.oid);
660  if (difference == 0)
661  difference = oidcmp((*middle)->catId.tableoid, catalogId.tableoid);
662  if (difference == 0)
663  return *middle;
664  else if (difference < 0)
665  low = middle + 1;
666  else
667  high = middle - 1;
668  }
669  return NULL;
670 }
Oid tableoid
Definition: pg_backup.h:230
#define oidcmp(x, y)
Definition: pg_dump.h:20
static int DOCatalogIdCompare(const void *p1, const void *p2)
Definition: common.c:737
static int numCatalogIds
Definition: common.c:38
Datum difference(PG_FUNCTION_ARGS)
#define free(a)
Definition: header.h:65
static DumpableObject ** catalogIdMap
Definition: common.c:37
static bool catalogIdMapValid
Definition: common.c:36
#define qsort(a, b, c, d)
Definition: port.h:488
void getDumpableObjects(DumpableObject ***objs, int *numObjs)
Definition: common.c:759

◆ findObjectByDumpId()

DumpableObject* findObjectByDumpId ( DumpId  dumpId)

Definition at line 609 of file common.c.

References allocedDumpIds.

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

610 {
611  if (dumpId <= 0 || dumpId >= allocedDumpIds)
612  return NULL; /* out of range? */
613  return dumpIdMap[dumpId];
614 }
static int allocedDumpIds
Definition: common.c:30
static DumpableObject ** dumpIdMap
Definition: common.c:29

◆ findObjectByOid()

static DumpableObject* findObjectByOid ( Oid  oid,
DumpableObject **  indexArray,
int  numObjs 
)
static

Definition at line 678 of file common.c.

References difference(), and oidcmp.

Referenced by findCollationByOid(), findExtensionByOid(), findFuncByOid(), findIndexByOid(), findNamespaceByOid(), findOprByOid(), findTableByOid(), and findTypeByOid().

679 {
680  DumpableObject **low;
681  DumpableObject **high;
682 
683  /*
684  * This is the same as findObjectByCatalogId except we assume we need not
685  * look at table OID because the objects are all the same type.
686  *
687  * We could use bsearch() here, but the notational cruft of calling
688  * bsearch is nearly as bad as doing it ourselves; and the generalized
689  * bsearch function is noticeably slower as well.
690  */
691  if (numObjs <= 0)
692  return NULL;
693  low = indexArray;
694  high = indexArray + (numObjs - 1);
695  while (low <= high)
696  {
697  DumpableObject **middle;
698  int difference;
699 
700  middle = low + (high - low) / 2;
701  difference = oidcmp((*middle)->catId.oid, oid);
702  if (difference == 0)
703  return *middle;
704  else if (difference < 0)
705  low = middle + 1;
706  else
707  high = middle - 1;
708  }
709  return NULL;
710 }
#define oidcmp(x, y)
Definition: pg_dump.h:20
Datum difference(PG_FUNCTION_ARGS)

◆ findOprByOid()

OprInfo* findOprByOid ( Oid  oid)

Definition at line 861 of file common.c.

References findObjectByOid(), and numOperators.

Referenced by getFormattedOperatorName().

862 {
864 }
static DumpableObject ** oprinfoindex
Definition: common.c:51
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static int numOperators
Definition: common.c:58

◆ findOwningExtension()

ExtensionInfo* findOwningExtension ( CatalogId  catalogId)

Definition at line 933 of file common.c.

References _extensionMemberId::catId, difference(), _extensionMemberId::ext, extmembers, numextmembers, CatalogId::oid, oidcmp, and CatalogId::tableoid.

Referenced by checkExtensionMembership().

934 {
935  ExtensionMemberId *low;
936  ExtensionMemberId *high;
937 
938  /*
939  * We could use bsearch() here, but the notational cruft of calling
940  * bsearch is nearly as bad as doing it ourselves; and the generalized
941  * bsearch function is noticeably slower as well.
942  */
943  if (numextmembers <= 0)
944  return NULL;
945  low = extmembers;
946  high = extmembers + (numextmembers - 1);
947  while (low <= high)
948  {
949  ExtensionMemberId *middle;
950  int difference;
951 
952  middle = low + (high - low) / 2;
953  /* comparison must match ExtensionMemberIdCompare, below */
954  difference = oidcmp(middle->catId.oid, catalogId.oid);
955  if (difference == 0)
956  difference = oidcmp(middle->catId.tableoid, catalogId.tableoid);
957  if (difference == 0)
958  return middle->ext;
959  else if (difference < 0)
960  low = middle + 1;
961  else
962  high = middle - 1;
963  }
964  return NULL;
965 }
ExtensionInfo * ext
Definition: pg_dump.h:636
Oid tableoid
Definition: pg_backup.h:230
#define oidcmp(x, y)
Definition: pg_dump.h:20
Datum difference(PG_FUNCTION_ARGS)
static ExtensionMemberId * extmembers
Definition: common.c:64
static int numextmembers
Definition: common.c:65
CatalogId catId
Definition: pg_dump.h:635

◆ findParentsByOid()

static void findParentsByOid ( TableInfo self,
InhInfo inhinfo,
int  numInherits 
)
static

Definition at line 993 of file common.c.

References exit_nicely, findTableByOid(), i, _tableInfo::parents, pg_log_error, and pg_malloc().

Referenced by flagInhTables().

995 {
996  Oid oid = self->dobj.catId.oid;
997  int i,
998  j;
999  int numParents;
1000 
1001  numParents = 0;
1002  for (i = 0; i < numInherits; i++)
1003  {
1004  if (inhinfo[i].inhrelid == oid)
1005  numParents++;
1006  }
1007 
1008  self->numParents = numParents;
1009 
1010  if (numParents > 0)
1011  {
1012  self->parents = (TableInfo **)
1013  pg_malloc(sizeof(TableInfo *) * numParents);
1014  j = 0;
1015  for (i = 0; i < numInherits; i++)
1016  {
1017  if (inhinfo[i].inhrelid == oid)
1018  {
1019  TableInfo *parent;
1020 
1021  parent = findTableByOid(inhinfo[i].inhparent);
1022  if (parent == NULL)
1023  {
1024  pg_log_error("failed sanity check, parent OID %u of table \"%s\" (OID %u) not found",
1025  inhinfo[i].inhparent,
1026  self->dobj.name,
1027  oid);
1028  exit_nicely(1);
1029  }
1030  self->parents[j++] = parent;
1031  }
1032  }
1033  }
1034  else
1035  self->parents = NULL;
1036 }
char * name
Definition: pg_dump.h:130
TableInfo * findTableByOid(Oid oid)
Definition: common.c:828
struct _tableInfo ** parents
Definition: pg_dump.h:330
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
#define pg_log_error(...)
Definition: logging.h:79
unsigned int Oid
Definition: postgres_ext.h:31
DumpableObject dobj
Definition: pg_dump.h:258
#define exit_nicely(code)
Definition: pg_dumpall.c:95
int i

◆ findTableByOid()

TableInfo* findTableByOid ( Oid  oid)

Definition at line 828 of file common.c.

References findObjectByOid(), and numTables.

Referenced by dumpSequence(), findParentsByOid(), getConstraints(), getOwnedSeqs(), getRules(), getTableDataFKConstraints(), processExtensionTables(), and selectDumpableType().

829 {
831 }
static int numTables
Definition: common.c:55
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static DumpableObject ** tblinfoindex
Definition: common.c:48

◆ findTypeByOid()

TypeInfo* findTypeByOid ( Oid  oid)

Definition at line 839 of file common.c.

References findObjectByOid(), and numTypes.

Referenced by DOTypeNameCompare(), getCasts(), and getTransforms().

840 {
841  return (TypeInfo *) findObjectByOid(oid, typinfoindex, numTypes);
842 }
static int numTypes
Definition: common.c:56
static DumpableObject * findObjectByOid(Oid oid, DumpableObject **indexArray, int numObjs)
Definition: common.c:678
static DumpableObject ** typinfoindex
Definition: common.c:49

◆ flagInhAttrs()

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

Definition at line 439 of file common.c.

References addObjectDependency(), _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, AssignDumpId(), _tableInfo::attisdropped, _tableInfo::attnames, _tableInfo::attrdefs, _dumpableObject::catId, DO_ATTRDEF, _tableInfo::dobj, _attrDefInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, i, _tableInfo::inhNotNull, _dumpableObject::name, _tableInfo::notnull, _tableInfo::numatts, _tableInfo::numParents, numTables, _dumpableObject::objType, CatalogId::oid, _tableInfo::parents, pg_malloc(), pg_strdup(), _tableInfo::relkind, _attrDefInfo::separate, shouldPrintColumn(), strInArray(), and CatalogId::tableoid.

Referenced by getSchemaData().

440 {
441  int i,
442  j,
443  k;
444 
445  for (i = 0; i < numTables; i++)
446  {
447  TableInfo *tbinfo = &(tblinfo[i]);
448  int numParents;
449  TableInfo **parents;
450 
451  /* Some kinds never have parents */
452  if (tbinfo->relkind == RELKIND_SEQUENCE ||
453  tbinfo->relkind == RELKIND_VIEW ||
454  tbinfo->relkind == RELKIND_MATVIEW)
455  continue;
456 
457  /* Don't bother computing anything for non-target tables, either */
458  if (!tbinfo->dobj.dump)
459  continue;
460 
461  numParents = tbinfo->numParents;
462  parents = tbinfo->parents;
463 
464  if (numParents == 0)
465  continue; /* nothing to see here, move along */
466 
467  /* For each column, search for matching column names in parent(s) */
468  for (j = 0; j < tbinfo->numatts; j++)
469  {
470  bool foundNotNull; /* Attr was NOT NULL in a parent */
471  bool foundDefault; /* Found a default in a parent */
472 
473  /* no point in examining dropped columns */
474  if (tbinfo->attisdropped[j])
475  continue;
476 
477  foundNotNull = false;
478  foundDefault = false;
479  for (k = 0; k < numParents; k++)
480  {
481  TableInfo *parent = parents[k];
482  int inhAttrInd;
483 
484  inhAttrInd = strInArray(tbinfo->attnames[j],
485  parent->attnames,
486  parent->numatts);
487  if (inhAttrInd >= 0)
488  {
489  foundNotNull |= parent->notnull[inhAttrInd];
490  foundDefault |= (parent->attrdefs[inhAttrInd] != NULL);
491  }
492  }
493 
494  /* Remember if we found inherited NOT NULL */
495  tbinfo->inhNotNull[j] = foundNotNull;
496 
497  /* Manufacture a DEFAULT NULL clause if necessary */
498  if (foundDefault && tbinfo->attrdefs[j] == NULL)
499  {
500  AttrDefInfo *attrDef;
501 
502  attrDef = (AttrDefInfo *) pg_malloc(sizeof(AttrDefInfo));
503  attrDef->dobj.objType = DO_ATTRDEF;
504  attrDef->dobj.catId.tableoid = 0;
505  attrDef->dobj.catId.oid = 0;
506  AssignDumpId(&attrDef->dobj);
507  attrDef->dobj.name = pg_strdup(tbinfo->dobj.name);
508  attrDef->dobj.namespace = tbinfo->dobj.namespace;
509  attrDef->dobj.dump = tbinfo->dobj.dump;
510 
511  attrDef->adtable = tbinfo;
512  attrDef->adnum = j + 1;
513  attrDef->adef_expr = pg_strdup("NULL");
514 
515  /* Will column be dumped explicitly? */
516  if (shouldPrintColumn(dopt, tbinfo, j))
517  {
518  attrDef->separate = false;
519  /* No dependency needed: NULL cannot have dependencies */
520  }
521  else
522  {
523  /* column will be suppressed, print default separately */
524  attrDef->separate = true;
525  /* ensure it comes out after the table */
526  addObjectDependency(&attrDef->dobj,
527  tbinfo->dobj.dumpId);
528  }
529 
530  tbinfo->attrdefs[j] = attrDef;
531  }
532  }
533  }
534 }
char * name
Definition: pg_dump.h:130
struct _tableInfo ** parents
Definition: pg_dump.h:330
char relkind
Definition: pg_dump.h:264
DumpComponents dump
Definition: pg_dump.h:131
Oid tableoid
Definition: pg_backup.h:230
void AssignDumpId(DumpableObject *dobj)
Definition: common.c:545
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
bool shouldPrintColumn(DumpOptions *dopt, TableInfo *tbinfo, int colno)
Definition: pg_dump.c:8695
bool * inhNotNull
Definition: pg_dump.h:318
DumpId dumpId
Definition: pg_dump.h:129
static int numTables
Definition: common.c:55
char ** attnames
Definition: pg_dump.h:301
DumpableObject dobj
Definition: pg_dump.h:258
static int strInArray(const char *pattern, char **arr, int arr_size)
Definition: common.c:1101
bool separate
Definition: pg_dump.h:344
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
bool * attisdropped
Definition: pg_dump.h:307
TableInfo * adtable
Definition: pg_dump.h:341
int numatts
Definition: pg_dump.h:300
bool * notnull
Definition: pg_dump.h:317
DumpableObject dobj
Definition: pg_dump.h:340
struct _attrDefInfo ** attrdefs
Definition: pg_dump.h:319
void addObjectDependency(DumpableObject *dobj, DumpId refId)
Definition: common.c:781
CatalogId catId
Definition: pg_dump.h:128
int i
int numParents
Definition: pg_dump.h:329
DumpableObjectType objType
Definition: pg_dump.h:127
char * adef_expr
Definition: pg_dump.h:343

◆ flagInhIndexes() [1/2]

static void flagInhIndexes ( Archive fout,
TableInfo tblinfo,
int  numTables 
)
static

Referenced by getSchemaData().

◆ flagInhIndexes() [2/2]

static void flagInhIndexes ( Archive fout,
TableInfo  tblinfo[],
int  numTables 
)
static

Definition at line 332 of file common.c.

References addObjectDependency(), Assert, AssignDumpId(), buildIndexArray(), _dumpableObject::catId, DO_INDEX_ATTACH, _tableInfo::dobj, _indxInfo::dobj, _indexAttachInfo::dobj, _dumpableObject::dumpId, findIndexByOid(), getMaxDumpId(), i, _tableInfo::indexes, _indxInfo::indextable, _dumpableObject::name, _tableInfo::numIndexes, numTables, _dumpableObject::objType, CatalogId::oid, _indxInfo::parentidx, _indexAttachInfo::parentIdx, _tableInfo::parents, _indxInfo::partattaches, _indexAttachInfo::partitionIdx, pg_free(), pg_malloc0(), pg_strdup(), simple_ptr_list_append(), and CatalogId::tableoid.

333 {
334  int i,
335  j,
336  k;
337  DumpableObject ***parentIndexArray;
338 
339  parentIndexArray = (DumpableObject ***)
340  pg_malloc0(getMaxDumpId() * sizeof(DumpableObject **));
341 
342  for (i = 0; i < numTables; i++)
343  {
344  TableInfo *parenttbl;
345  IndexAttachInfo *attachinfo;
346 
347  if (!tblinfo[i].ispartition || tblinfo[i].numParents == 0)
348  continue;
349 
350  Assert(tblinfo[i].numParents == 1);
351  parenttbl = tblinfo[i].parents[0];
352 
353  /*
354  * We need access to each parent table's index list, but there is no
355  * index to cover them outside of this function. To avoid having to
356  * sort every parent table's indexes each time we come across each of
357  * its partitions, create an indexed array for each parent the first
358  * time it is required.
359  */
360  if (parentIndexArray[parenttbl->dobj.dumpId] == NULL)
361  parentIndexArray[parenttbl->dobj.dumpId] =
362  buildIndexArray(parenttbl->indexes,
363  parenttbl->numIndexes,
364  sizeof(IndxInfo));
365 
366  attachinfo = (IndexAttachInfo *)
367  pg_malloc0(tblinfo[i].numIndexes * sizeof(IndexAttachInfo));
368  for (j = 0, k = 0; j < tblinfo[i].numIndexes; j++)
369  {
370  IndxInfo *index = &(tblinfo[i].indexes[j]);
371  IndxInfo *parentidx;
372 
373  if (index->parentidx == 0)
374  continue;
375 
376  parentidx = findIndexByOid(index->parentidx,
377  parentIndexArray[parenttbl->dobj.dumpId],
378  parenttbl->numIndexes);
379  if (parentidx == NULL)
380  continue;
381 
382  attachinfo[k].dobj.objType = DO_INDEX_ATTACH;
383  attachinfo[k].dobj.catId.tableoid = 0;
384  attachinfo[k].dobj.catId.oid = 0;
385  AssignDumpId(&attachinfo[k].dobj);
386  attachinfo[k].dobj.name = pg_strdup(index->dobj.name);
387  attachinfo[k].dobj.namespace = index->indextable->dobj.namespace;
388  attachinfo[k].parentIdx = parentidx;
389  attachinfo[k].partitionIdx = index;
390 
391  /*
392  * We must state the DO_INDEX_ATTACH object's dependencies
393  * explicitly, since it will not match anything in pg_depend.
394  *
395  * Give it dependencies on both the partition index and the parent
396  * index, so that it will not be executed till both of those
397  * exist. (There's no need to care what order those are created
398  * in.)
399  *
400  * In addition, give it dependencies on the indexes' underlying
401  * tables. This does nothing of great value so far as serial
402  * restore ordering goes, but it ensures that a parallel restore
403  * will not try to run the ATTACH concurrently with other
404  * operations on those tables.
405  */
406  addObjectDependency(&attachinfo[k].dobj, index->dobj.dumpId);
407  addObjectDependency(&attachinfo[k].dobj, parentidx->dobj.dumpId);
408  addObjectDependency(&attachinfo[k].dobj,
409  index->indextable->dobj.dumpId);
410  addObjectDependency(&attachinfo[k].dobj,
411  parentidx->indextable->dobj.dumpId);
412 
413  /* keep track of the list of partitions in the parent index */
414  simple_ptr_list_append(&parentidx->partattaches, &attachinfo[k].dobj);
415 
416  k++;
417  }
418  }
419 
420  for (i = 0; i < numTables; i++)
421  if (parentIndexArray[i])
422  pg_free(parentIndexArray[i]);
423  pg_free(parentIndexArray);
424 }
char * name
Definition: pg_dump.h:130
struct _tableInfo ** parents
Definition: pg_dump.h:330
Oid tableoid
Definition: pg_backup.h:230
void AssignDumpId(DumpableObject *dobj)
Definition: common.c:545
DumpId dumpId
Definition: pg_dump.h:129
static int numTables
Definition: common.c:55
DumpableObject dobj
Definition: pg_dump.h:258
Oid parentidx
Definition: pg_dump.h:369
static DumpableObject ** buildIndexArray(void *objArray, int numObjs, Size objSize)
Definition: common.c:716
Definition: type.h:89
DumpableObject dobj
Definition: pg_dump.h:378
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
TableInfo * indextable
Definition: pg_dump.h:357
IndxInfo * partitionIdx
Definition: pg_dump.h:380
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static IndxInfo * findIndexByOid(Oid oid, DumpableObject **idxinfoindex, int numIndexes)
Definition: common.c:907
SimplePtrList partattaches
Definition: pg_dump.h:370
int numIndexes
Definition: pg_dump.h:331
DumpId getMaxDumpId(void)
Definition: common.c:598
#define Assert(condition)
Definition: c.h:739
IndxInfo * parentIdx
Definition: pg_dump.h:379
void pg_free(void *ptr)
Definition: fe_memutils.c:105
void addObjectDependency(DumpableObject *dobj, DumpId refId)
Definition: common.c:781
CatalogId catId
Definition: pg_dump.h:128
struct _indxInfo * indexes
Definition: pg_dump.h:332
DumpableObject dobj
Definition: pg_dump.h:356
void simple_ptr_list_append(SimplePtrList *list, void *ptr)
Definition: simple_list.c:162
int i
DumpableObjectType objType
Definition: pg_dump.h:127

◆ flagInhTables()

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

Definition at line 273 of file common.c.

References Archive::dopt, findParentsByOid(), i, _tableInfo::ispartition, _dumpOptions::load_via_partition_root, _tableInfo::numParents, numTables, _tableInfo::parents, and relkind.

Referenced by getSchemaData().

275 {
276  DumpOptions *dopt = fout->dopt;
277  int i,
278  j;
279 
280  for (i = 0; i < numTables; i++)
281  {
282  bool find_parents = true;
283  bool mark_parents = true;
284 
285  /* Some kinds never have parents */
286  if (tblinfo[i].relkind == RELKIND_SEQUENCE ||
287  tblinfo[i].relkind == RELKIND_VIEW ||
288  tblinfo[i].relkind == RELKIND_MATVIEW)
289  continue;
290 
291  /*
292  * Normally, we don't bother computing anything for non-target tables,
293  * but if load-via-partition-root is specified, we gather information
294  * on every partition in the system so that getRootTableInfo can trace
295  * from any given to leaf partition all the way up to the root. (We
296  * don't need to mark them as interesting for getTableAttrs, though.)
297  */
298  if (!tblinfo[i].dobj.dump)
299  {
300  mark_parents = false;
301 
302  if (!dopt->load_via_partition_root ||
303  !tblinfo[i].ispartition)
304  find_parents = false;
305  }
306 
307  /* If needed, find all the immediate parent tables. */
308  if (find_parents)
309  findParentsByOid(&tblinfo[i], inhinfo, numInherits);
310 
311  /*
312  * If needed, mark the parents as interesting for getTableAttrs and
313  * getIndexes.
314  */
315  if (mark_parents)
316  {
317  int numParents = tblinfo[i].numParents;
318  TableInfo **parents = tblinfo[i].parents;
319 
320  for (j = 0; j < numParents; j++)
321  parents[j]->interesting = true;
322  }
323  }
324 }
struct _tableInfo ** parents
Definition: pg_dump.h:330
static void findParentsByOid(TableInfo *self, InhInfo *inhinfo, int numInherits)
Definition: common.c:993
static int numTables
Definition: common.c:55
char relkind
Definition: pg_class.h:81
DumpOptions * dopt
Definition: pg_backup.h:182
int i
int load_via_partition_root
Definition: pg_backup.h:160

◆ getDumpableObjects()

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

Definition at line 759 of file common.c.

References allocedDumpIds, i, and pg_malloc().

Referenced by findObjectByCatalogId(), getTableDataFKConstraints(), and main().

760 {
761  int i,
762  j;
763 
764  *objs = (DumpableObject **)
766  j = 0;
767  for (i = 1; i < allocedDumpIds; i++)
768  {
769  if (dumpIdMap[i])
770  (*objs)[j++] = dumpIdMap[i];
771  }
772  *numObjs = j;
773 }
static int allocedDumpIds
Definition: common.c:30
static DumpableObject ** dumpIdMap
Definition: common.c:29
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
int i

◆ getMaxDumpId()

DumpId getMaxDumpId ( void  )

Definition at line 598 of file common.c.

References lastDumpId.

Referenced by findDependencyLoops(), flagInhIndexes(), and TopoSort().

599 {
600  return lastDumpId;
601 }
static DumpId lastDumpId
Definition: common.c:31

◆ getSchemaData()

TableInfo* getSchemaData ( Archive fout,
int *  numTablesPtr 
)

Definition at line 87 of file common.c.

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

Referenced by main().

88 {
89  TableInfo *tblinfo;
91  FuncInfo *funinfo;
92  OprInfo *oprinfo;
93  CollInfo *collinfo;
94  NamespaceInfo *nspinfo;
95  ExtensionInfo *extinfo;
96  InhInfo *inhinfo;
97  int numAggregates;
98  int numInherits;
99  int numRules;
100  int numProcLangs;
101  int numCasts;
102  int numTransforms;
103  int numAccessMethods;
104  int numOpclasses;
105  int numOpfamilies;
106  int numConversions;
107  int numTSParsers;
108  int numTSTemplates;
109  int numTSDicts;
110  int numTSConfigs;
111  int numForeignDataWrappers;
112  int numForeignServers;
113  int numDefaultACLs;
114  int numEventTriggers;
115 
116  /*
117  * We must read extensions and extension membership info first, because
118  * extension membership needs to be consultable during decisions about
119  * whether other objects are to be dumped.
120  */
121  pg_log_info("reading extensions");
122  extinfo = getExtensions(fout, &numExtensions);
124 
125  pg_log_info("identifying extension members");
126  getExtensionMembership(fout, extinfo, numExtensions);
127 
128  pg_log_info("reading schemas");
129  nspinfo = getNamespaces(fout, &numNamespaces);
131 
132  /*
133  * getTables should be done as soon as possible, so as to minimize the
134  * window between starting our transaction and acquiring per-table locks.
135  * However, we have to do getNamespaces first because the tables get
136  * linked to their containing namespaces during getTables.
137  */
138  pg_log_info("reading user-defined tables");
139  tblinfo = getTables(fout, &numTables);
140  tblinfoindex = buildIndexArray(tblinfo, numTables, sizeof(TableInfo));
141 
142  /* Do this after we've built tblinfoindex */
143  getOwnedSeqs(fout, tblinfo, numTables);
144 
145  pg_log_info("reading user-defined functions");
146  funinfo = getFuncs(fout, &numFuncs);
147  funinfoindex = buildIndexArray(funinfo, numFuncs, sizeof(FuncInfo));
148 
149  /* this must be after getTables and getFuncs */
150  pg_log_info("reading user-defined types");
151  typinfo = getTypes(fout, &numTypes);
152  typinfoindex = buildIndexArray(typinfo, numTypes, sizeof(TypeInfo));
153 
154  /* this must be after getFuncs, too */
155  pg_log_info("reading procedural languages");
156  getProcLangs(fout, &numProcLangs);
157 
158  pg_log_info("reading user-defined aggregate functions");
159  getAggregates(fout, &numAggregates);
160 
161  pg_log_info("reading user-defined operators");
162  oprinfo = getOperators(fout, &numOperators);
163  oprinfoindex = buildIndexArray(oprinfo, numOperators, sizeof(OprInfo));
164 
165  pg_log_info("reading user-defined access methods");
166  getAccessMethods(fout, &numAccessMethods);
167 
168  pg_log_info("reading user-defined operator classes");
169  getOpclasses(fout, &numOpclasses);
170 
171  pg_log_info("reading user-defined operator families");
172  getOpfamilies(fout, &numOpfamilies);
173 
174  pg_log_info("reading user-defined text search parsers");
175  getTSParsers(fout, &numTSParsers);
176 
177  pg_log_info("reading user-defined text search templates");
178  getTSTemplates(fout, &numTSTemplates);
179 
180  pg_log_info("reading user-defined text search dictionaries");
181  getTSDictionaries(fout, &numTSDicts);
182 
183  pg_log_info("reading user-defined text search configurations");
184  getTSConfigurations(fout, &numTSConfigs);
185 
186  pg_log_info("reading user-defined foreign-data wrappers");
187  getForeignDataWrappers(fout, &numForeignDataWrappers);
188 
189  pg_log_info("reading user-defined foreign servers");
190  getForeignServers(fout, &numForeignServers);
191 
192  pg_log_info("reading default privileges");
193  getDefaultACLs(fout, &numDefaultACLs);
194 
195  pg_log_info("reading user-defined collations");
196  collinfo = getCollations(fout, &numCollations);
197  collinfoindex = buildIndexArray(collinfo, numCollations, sizeof(CollInfo));
198 
199  pg_log_info("reading user-defined conversions");
200  getConversions(fout, &numConversions);
201 
202  pg_log_info("reading type casts");
203  getCasts(fout, &numCasts);
204 
205  pg_log_info("reading transforms");
206  getTransforms(fout, &numTransforms);
207 
208  pg_log_info("reading table inheritance information");
209  inhinfo = getInherits(fout, &numInherits);
210 
211  pg_log_info("reading event triggers");
212  getEventTriggers(fout, &numEventTriggers);
213 
214  /* Identify extension configuration tables that should be dumped */
215  pg_log_info("finding extension tables");
216  processExtensionTables(fout, extinfo, numExtensions);
217 
218  /* Link tables to parents, mark parents of target tables interesting */
219  pg_log_info("finding inheritance relationships");
220  flagInhTables(fout, tblinfo, numTables, inhinfo, numInherits);
221 
222  pg_log_info("reading column info for interesting tables");
223  getTableAttrs(fout, tblinfo, numTables);
224 
225  pg_log_info("flagging inherited columns in subtables");
226  flagInhAttrs(fout->dopt, tblinfo, numTables);
227 
228  pg_log_info("reading indexes");
229  getIndexes(fout, tblinfo, numTables);
230 
231  pg_log_info("flagging indexes in partitioned tables");
232  flagInhIndexes(fout, tblinfo, numTables);
233 
234  pg_log_info("reading extended statistics");
235  getExtendedStatistics(fout);
236 
237  pg_log_info("reading constraints");
238  getConstraints(fout, tblinfo, numTables);
239 
240  pg_log_info("reading triggers");
241  getTriggers(fout, tblinfo, numTables);
242 
243  pg_log_info("reading rewrite rules");
244  getRules(fout, &numRules);
245 
246  pg_log_info("reading policies");
247  getPolicies(fout, tblinfo, numTables);
248 
249  pg_log_info("reading publications");
250  getPublications(fout);
251 
252  pg_log_info("reading publication membership");
253  getPublicationTables(fout, tblinfo, numTables);
254 
255  pg_log_info("reading subscriptions");
256  getSubscriptions(fout);
257 
258  *numTablesPtr = numTables;
259  return tblinfo;
260 }
FuncInfo * getFuncs(Archive *fout, int *numFuncs)
Definition: pg_dump.c:5660
static DumpableObject ** collinfoindex
Definition: common.c:52
static int numTypes
Definition: common.c:56
AggInfo * getAggregates(Archive *fout, int *numAggs)
Definition: pg_dump.c:5466
void getPublicationTables(Archive *fout, TableInfo tblinfo[], int numTables)
Definition: pg_dump.c:3950
CollInfo * getCollations(Archive *fout, int *numCollations)
Definition: pg_dump.c:5080
OprInfo * getOperators(Archive *fout, int *numOprs)
Definition: pg_dump.c:4997
static DumpableObject ** oprinfoindex
Definition: common.c:51
TransformInfo * getTransforms(Archive *fout, int *numTransforms)
Definition: pg_dump.c:8158
DefaultACLInfo * getDefaultACLs(Archive *fout, int *numDefaultACLs)
Definition: pg_dump.c:9357
static void flagInhTables(Archive *fout, TableInfo *tbinfo, int numTables, InhInfo *inhinfo, int numInherits)
Definition: common.c:273
static int numFuncs
Definition: common.c:57
AccessMethodInfo * getAccessMethods(Archive *fout, int *numAccessMethods)
Definition: pg_dump.c:5233
OpclassInfo * getOpclasses(Archive *fout, int *numOpclasses)
Definition: pg_dump.c:5307
TSConfigInfo * getTSConfigurations(Archive *fout, int *numTSConfigs)
Definition: pg_dump.c:8964
static int numTables
Definition: common.c:55
static DumpableObject ** buildIndexArray(void *objArray, int numObjs, Size objSize)
Definition: common.c:716
TSParserInfo * getTSParsers(Archive *fout, int *numTSParsers)
Definition: pg_dump.c:8713
static DumpableObject ** typinfoindex
Definition: common.c:49
void getConstraints(Archive *fout, TableInfo tblinfo[], int numTables)
Definition: pg_dump.c:7246
static void flagInhIndexes(Archive *fout, TableInfo *tblinfo, int numTables)
InhInfo * getInherits(Archive *fout, int *numInherits)
Definition: pg_dump.c:6767
static int numOperators
Definition: common.c:58
DumpOptions * dopt
Definition: pg_backup.h:182
TableInfo * getTables(Archive *fout, int *numTables)
Definition: pg_dump.c:5895
void getPolicies(Archive *fout, TableInfo tblinfo[], int numTables)
Definition: pg_dump.c:3508
EventTriggerInfo * getEventTriggers(Archive *fout, int *numEventTriggers)
Definition: pg_dump.c:7776
static DumpableObject ** tblinfoindex
Definition: common.c:48
NamespaceInfo * getNamespaces(Archive *fout, int *numNamespaces)
Definition: pg_dump.c:4517
static int numExtensions
Definition: common.c:61
static int numNamespaces
Definition: common.c:60
RuleInfo * getRules(Archive *fout, int *numRules)
Definition: pg_dump.c:7469
FdwInfo * getForeignDataWrappers(Archive *fout, int *numForeignDataWrappers)
Definition: pg_dump.c:9041
void processExtensionTables(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition: pg_dump.c:17793
void getSubscriptions(Archive *fout)
Definition: pg_dump.c:4095
void getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
Definition: pg_dump.c:6816
TSDictInfo * getTSDictionaries(Archive *fout, int *numTSDicts)
Definition: pg_dump.c:8804
void getTriggers(Archive *fout, TableInfo tblinfo[], int numTables)
Definition: pg_dump.c:7582
void getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables)
Definition: pg_dump.c:8255
void getOwnedSeqs(Archive *fout, TableInfo tblinfo[], int numTables)
Definition: pg_dump.c:6704
ConvInfo * getConversions(Archive *fout, int *numConversions)
Definition: pg_dump.c:5160
OpfamilyInfo * getOpfamilies(Archive *fout, int *numOpfamilies)
Definition: pg_dump.c:5382
TSTemplateInfo * getTSTemplates(Archive *fout, int *numTSTemplates)
Definition: pg_dump.c:8888
static int numCollations
Definition: common.c:59
void getExtendedStatistics(Archive *fout)
Definition: pg_dump.c:7168
ExtensionInfo * getExtensions(Archive *fout, int *numExtensions)
Definition: pg_dump.c:4663
TypeInfo * getTypes(Archive *fout, int *numTypes)
Definition: pg_dump.c:4747
static DumpableObject ** extinfoindex
Definition: common.c:54
void getPublications(Archive *fout)
Definition: pg_dump.c:3768
ForeignServerInfo * getForeignServers(Archive *fout, int *numForeignServers)
Definition: pg_dump.c:9207
static DumpableObject ** funinfoindex
Definition: common.c:50
static DumpableObject ** nspinfoindex
Definition: common.c:53
ProcLangInfo * getProcLangs(Archive *fout, int *numProcLangs)
Definition: pg_dump.c:7867
void getExtensionMembership(Archive *fout, ExtensionInfo extinfo[], int numExtensions)
Definition: pg_dump.c:17688
static void flagInhAttrs(DumpOptions *dopt, TableInfo *tblinfo, int numTables)
Definition: common.c:439
#define pg_log_info(...)
Definition: logging.h:87
CastInfo * getCasts(Archive *fout, int *numCasts)
Definition: pg_dump.c:8045

◆ parseOidArray()

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

Definition at line 1048 of file common.c.

References atooid, exit_nicely, InvalidOid, and pg_log_error.

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

1049 {
1050  int j,
1051  argNum;
1052  char temp[100];
1053  char s;
1054 
1055  argNum = 0;
1056  j = 0;
1057  for (;;)
1058  {
1059  s = *str++;
1060  if (s == ' ' || s == '\0')
1061  {
1062  if (j > 0)
1063  {
1064  if (argNum >= arraysize)
1065  {
1066  pg_log_error("could not parse numeric array \"%s\": too many numbers", str);
1067  exit_nicely(1);
1068  }
1069  temp[j] = '\0';
1070  array[argNum++] = atooid(temp);
1071  j = 0;
1072  }
1073  if (s == '\0')
1074  break;
1075  }
1076  else
1077  {
1078  if (!(isdigit((unsigned char) s) || s == '-') ||
1079  j >= sizeof(temp) - 1)
1080  {
1081  pg_log_error("could not parse numeric array \"%s\": invalid character in number", str);
1082  exit_nicely(1);
1083  }
1084  temp[j++] = s;
1085  }
1086  }
1087 
1088  while (argNum < arraysize)
1089  array[argNum++] = InvalidOid;
1090 }
#define pg_log_error(...)
Definition: logging.h:79
#define atooid(x)
Definition: postgres_ext.h:42
#define exit_nicely(code)
Definition: pg_dumpall.c:95
#define InvalidOid
Definition: postgres_ext.h:36

◆ removeObjectDependency()

void removeObjectDependency ( DumpableObject dobj,
DumpId  refId 
)

◆ setExtensionMembership()

void setExtensionMembership ( ExtensionMemberId extmems,
int  nextmems 
)

Definition at line 917 of file common.c.

References ExtensionMemberIdCompare(), numextmembers, and qsort.

Referenced by getExtensionMembership().

918 {
919  /* Sort array in preparation for binary searches */
920  if (nextmems > 1)
921  qsort((void *) extmems, nextmems, sizeof(ExtensionMemberId),
923  /* And save */
924  extmembers = extmems;
925  numextmembers = nextmems;
926 }
static int ExtensionMemberIdCompare(const void *p1, const void *p2)
Definition: common.c:971
static ExtensionMemberId * extmembers
Definition: common.c:64
static int numextmembers
Definition: common.c:65
#define qsort(a, b, c, d)
Definition: port.h:488

◆ strInArray()

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

Definition at line 1101 of file common.c.

References i.

Referenced by flagInhAttrs().

1102 {
1103  int i;
1104 
1105  for (i = 0; i < arr_size; i++)
1106  {
1107  if (strcmp(pattern, arr[i]) == 0)
1108  return i;
1109  }
1110  return -1;
1111 }
int i

Variable Documentation

◆ allocedDumpIds

int allocedDumpIds = 0
static

Definition at line 30 of file common.c.

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

◆ catalogIdMap

DumpableObject** catalogIdMap = NULL
static

Definition at line 37 of file common.c.

Referenced by findObjectByCatalogId().

◆ catalogIdMapValid

bool catalogIdMapValid = false
static

Definition at line 36 of file common.c.

Referenced by AssignDumpId(), and findObjectByCatalogId().

◆ collinfoindex

DumpableObject** collinfoindex
static

Definition at line 52 of file common.c.

◆ dumpIdMap

DumpableObject** dumpIdMap = NULL
static

Definition at line 29 of file common.c.

◆ extinfoindex

DumpableObject** extinfoindex
static

Definition at line 54 of file common.c.

◆ extmembers

ExtensionMemberId* extmembers
static

Definition at line 64 of file common.c.

Referenced by findOwningExtension(), and getExtensionMembership().

◆ funinfoindex

DumpableObject** funinfoindex
static

Definition at line 50 of file common.c.

◆ lastDumpId

DumpId lastDumpId = 0
static

Definition at line 31 of file common.c.

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

◆ nspinfoindex

DumpableObject** nspinfoindex
static

Definition at line 53 of file common.c.

◆ numCatalogIds

int numCatalogIds = 0
static

Definition at line 38 of file common.c.

Referenced by findObjectByCatalogId().

◆ numCollations

int numCollations
static

Definition at line 59 of file common.c.

Referenced by findCollationByOid(), and getSchemaData().

◆ numExtensions

int numExtensions
static

Definition at line 61 of file common.c.

Referenced by findExtensionByOid(), getSchemaData(), and processExtensionTables().

◆ numextmembers

int numextmembers
static

Definition at line 65 of file common.c.

Referenced by findOwningExtension(), and setExtensionMembership().

◆ numFuncs

int numFuncs
static

Definition at line 57 of file common.c.

Referenced by findFuncByOid(), and getSchemaData().

◆ numNamespaces

int numNamespaces
static

Definition at line 60 of file common.c.

Referenced by findNamespaceByOid(), and getSchemaData().

◆ numOperators

int numOperators
static

Definition at line 58 of file common.c.

Referenced by findOprByOid(), and getSchemaData().

◆ numTables

◆ numTypes

int numTypes
static

Definition at line 56 of file common.c.

Referenced by findTypeByOid(), and getSchemaData().

◆ oprinfoindex

DumpableObject** oprinfoindex
static

Definition at line 51 of file common.c.

◆ tblinfoindex

DumpableObject** tblinfoindex
static

Definition at line 48 of file common.c.

◆ typinfoindex

DumpableObject** typinfoindex
static

Definition at line 49 of file common.c.