pg_dump.c File Reference

#include "postgres_fe.h"
#include <unistd.h>
#include <ctype.h>
#include <limits.h>
#include "access/attnum.h"
#include "access/sysattr.h"
#include "access/transam.h"
#include "catalog/pg_aggregate_d.h"
#include "catalog/pg_am_d.h"
#include "catalog/pg_attribute_d.h"
#include "catalog/pg_authid_d.h"
#include "catalog/pg_cast_d.h"
#include "catalog/pg_class_d.h"
#include "catalog/pg_default_acl_d.h"
#include "catalog/pg_largeobject_d.h"
#include "catalog/pg_largeobject_metadata_d.h"
#include "catalog/pg_proc_d.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_trigger_d.h"
#include "catalog/pg_type_d.h"
#include "common/connect.h"
#include "common/relpath.h"
#include "compress_io.h"
#include "dumputils.h"
#include "fe_utils/option_utils.h"
#include "fe_utils/string_utils.h"
#include "getopt_long.h"
#include "libpq/libpq-fs.h"
#include "parallel.h"
#include "pg_backup_db.h"
#include "pg_backup_utils.h"
#include "pg_dump.h"
#include "storage/block.h"

Include dependency graph for pg_dump.c:

Go to the source code of this file.

Data Structures
struct	RoleNameItem
struct	CommentItem
struct	SecLabelItem

Macros
#define	DUMP_DEFAULT_ROWS_PER_INSERT   1
#define	fmtQualifiedDumpable(obj)

Typedefs
typedef enum OidOptions	OidOptions

Enumerations
enum	OidOptions { zeroIsError = 1 , zeroAsStar = 2 , zeroAsNone = 4 }

Functions
static void	help (const char *progname)
static void	setup_connection (Archive *AH, const char *dumpencoding, const char *dumpsnapshot, char *use_role)
static ArchiveFormat	parseArchiveFormat (const char *format, ArchiveMode *mode)
static void	expand_schema_name_patterns (Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
static void	expand_extension_name_patterns (Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names)
static void	expand_foreign_server_name_patterns (Archive *fout, SimpleStringList *patterns, SimpleOidList *oids)
static void	expand_table_name_patterns (Archive *fout, SimpleStringList *patterns, SimpleOidList *oids, bool strict_names, bool with_child_tables)
static void	prohibit_crossdb_refs (PGconn *conn, const char *dbname, const char *pattern)
static NamespaceInfo *	findNamespace (Oid nsoid)
static void	dumpTableData (Archive *fout, const TableDataInfo *tdinfo)
static void	refreshMatViewData (Archive *fout, const TableDataInfo *tdinfo)
static const char *	getRoleName (const char *roleoid_str)
static void	collectRoleNames (Archive *fout)
static void	getAdditionalACLs (Archive *fout)
static void	dumpCommentExtended (Archive *fout, const char *type, const char *name, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId, const char *initdb_comment)
static void	dumpComment (Archive *fout, const char *type, const char *name, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId)
static int	findComments (Oid classoid, Oid objoid, CommentItem **items)
static void	collectComments (Archive *fout)
static void	dumpSecLabel (Archive *fout, const char *type, const char *name, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId)
static int	findSecLabels (Oid classoid, Oid objoid, SecLabelItem **items)
static void	collectSecLabels (Archive *fout)
static void	dumpDumpableObject (Archive *fout, DumpableObject *dobj)
static void	dumpNamespace (Archive *fout, const NamespaceInfo *nspinfo)
static void	dumpExtension (Archive *fout, const ExtensionInfo *extinfo)
static void	dumpType (Archive *fout, const TypeInfo *tyinfo)
static void	dumpBaseType (Archive *fout, const TypeInfo *tyinfo)
static void	dumpEnumType (Archive *fout, const TypeInfo *tyinfo)
static void	dumpRangeType (Archive *fout, const TypeInfo *tyinfo)
static void	dumpUndefinedType (Archive *fout, const TypeInfo *tyinfo)
static void	dumpDomain (Archive *fout, const TypeInfo *tyinfo)
static void	dumpCompositeType (Archive *fout, const TypeInfo *tyinfo)
static void	dumpCompositeTypeColComments (Archive *fout, const TypeInfo *tyinfo, PGresult *res)
static void	dumpShellType (Archive *fout, const ShellTypeInfo *stinfo)
static void	dumpProcLang (Archive *fout, const ProcLangInfo *plang)
static void	dumpFunc (Archive *fout, const FuncInfo *finfo)
static void	dumpCast (Archive *fout, const CastInfo *cast)
static void	dumpTransform (Archive *fout, const TransformInfo *transform)
static void	dumpOpr (Archive *fout, const OprInfo *oprinfo)
static void	dumpAccessMethod (Archive *fout, const AccessMethodInfo *aminfo)
static void	dumpOpclass (Archive *fout, const OpclassInfo *opcinfo)
static void	dumpOpfamily (Archive *fout, const OpfamilyInfo *opfinfo)
static void	dumpCollation (Archive *fout, const CollInfo *collinfo)
static void	dumpConversion (Archive *fout, const ConvInfo *convinfo)
static void	dumpRule (Archive *fout, const RuleInfo *rinfo)
static void	dumpAgg (Archive *fout, const AggInfo *agginfo)
static void	dumpTrigger (Archive *fout, const TriggerInfo *tginfo)
static void	dumpEventTrigger (Archive *fout, const EventTriggerInfo *evtinfo)
static void	dumpTable (Archive *fout, const TableInfo *tbinfo)
static void	dumpTableSchema (Archive *fout, const TableInfo *tbinfo)
static void	dumpTableAttach (Archive *fout, const TableAttachInfo *attachinfo)
static void	dumpAttrDef (Archive *fout, const AttrDefInfo *adinfo)
static void	dumpSequence (Archive *fout, const TableInfo *tbinfo)
static void	dumpSequenceData (Archive *fout, const TableDataInfo *tdinfo)
static void	dumpIndex (Archive *fout, const IndxInfo *indxinfo)
static void	dumpIndexAttach (Archive *fout, const IndexAttachInfo *attachinfo)
static void	dumpStatisticsExt (Archive *fout, const StatsExtInfo *statsextinfo)
static void	dumpConstraint (Archive *fout, const ConstraintInfo *coninfo)
static void	dumpTableConstraintComment (Archive *fout, const ConstraintInfo *coninfo)
static void	dumpTSParser (Archive *fout, const TSParserInfo *prsinfo)
static void	dumpTSDictionary (Archive *fout, const TSDictInfo *dictinfo)
static void	dumpTSTemplate (Archive *fout, const TSTemplateInfo *tmplinfo)
static void	dumpTSConfig (Archive *fout, const TSConfigInfo *cfginfo)
static void	dumpForeignDataWrapper (Archive *fout, const FdwInfo *fdwinfo)
static void	dumpForeignServer (Archive *fout, const ForeignServerInfo *srvinfo)
static void	dumpUserMappings (Archive *fout, const char *servername, const char *namespace, const char *owner, CatalogId catalogId, DumpId dumpId)
static void	dumpDefaultACL (Archive *fout, const DefaultACLInfo *daclinfo)
static DumpId	dumpACL (Archive *fout, DumpId objDumpId, DumpId altDumpId, const char *type, const char *name, const char *subname, const char *nspname, const char *owner, const DumpableAcl *dacl)
static void	getDependencies (Archive *fout)
static void	BuildArchiveDependencies (Archive *fout)
static void	findDumpableDependencies (ArchiveHandle *AH, const DumpableObject *dobj, DumpId **dependencies, int *nDeps, int *allocDeps)
static DumpableObject *	createBoundaryObjects (void)
static void	addBoundaryDependencies (DumpableObject **dobjs, int numObjs, DumpableObject *boundaryObjs)
static void	addConstrChildIdxDeps (DumpableObject *dobj, const IndxInfo *refidx)
static void	getDomainConstraints (Archive *fout, TypeInfo *tyinfo)
static void	getTableData (DumpOptions *dopt, TableInfo *tblinfo, int numTables, char relkind)
static void	makeTableDataInfo (DumpOptions *dopt, TableInfo *tbinfo)
static void	buildMatViewRefreshDependencies (Archive *fout)
static void	getTableDataFKConstraints (void)
static char *	format_function_arguments (const FuncInfo *finfo, const char *funcargs, bool is_agg)
static char *	format_function_signature (Archive *fout, const FuncInfo *finfo, bool honor_quotes)
static char *	convertRegProcReference (const char *proc)
static char *	getFormattedOperatorName (const char *oproid)
static char *	convertTSFunction (Archive *fout, Oid funcOid)
static const char *	getFormattedTypeName (Archive *fout, Oid oid, OidOptions opts)
static void	getLOs (Archive *fout)
static void	dumpLO (Archive *fout, const LoInfo *loinfo)
static int	dumpLOs (Archive *fout, const void *arg)
static void	dumpPolicy (Archive *fout, const PolicyInfo *polinfo)
static void	dumpPublication (Archive *fout, const PublicationInfo *pubinfo)
static void	dumpPublicationTable (Archive *fout, const PublicationRelInfo *pubrinfo)
static void	dumpSubscription (Archive *fout, const SubscriptionInfo *subinfo)
static void	dumpDatabase (Archive *fout)
static void	dumpDatabaseConfig (Archive *AH, PQExpBuffer outbuf, const char *dbname, Oid dboid)
static void	dumpEncoding (Archive *AH)
static void	dumpStdStrings (Archive *AH)
static void	dumpSearchPath (Archive *AH)
static void	binary_upgrade_set_type_oids_by_type_oid (Archive *fout, PQExpBuffer upgrade_buffer, Oid pg_type_oid, bool force_array_type, bool include_multirange_type)
static void	binary_upgrade_set_type_oids_by_rel (Archive *fout, PQExpBuffer upgrade_buffer, const TableInfo *tbinfo)
static void	binary_upgrade_set_pg_class_oids (Archive *fout, PQExpBuffer upgrade_buffer, Oid pg_class_oid, bool is_index)
static void	binary_upgrade_extension_member (PQExpBuffer upgrade_buffer, const DumpableObject *dobj, const char *objtype, const char *objname, const char *objnamespace)
static const char *	getAttrName (int attrnum, const TableInfo *tblInfo)
static const char *	fmtCopyColumnList (const TableInfo *ti, PQExpBuffer buffer)
static bool	nonemptyReloptions (const char *reloptions)
static void	appendReloptionsArrayAH (PQExpBuffer buffer, const char *reloptions, const char *prefix, Archive *fout)
static char *	get_synchronized_snapshot (Archive *fout)
static void	setupDumpWorker (Archive *AH)
static TableInfo *	getRootTableInfo (const TableInfo *tbinfo)
static bool	forcePartitionRootLoad (const TableInfo *tbinfo)
int	main (int argc, char **argv)
static bool	checkExtensionMembership (DumpableObject *dobj, Archive *fout)
static void	selectDumpableNamespace (NamespaceInfo *nsinfo, Archive *fout)
static void	selectDumpableTable (TableInfo *tbinfo, Archive *fout)
static void	selectDumpableType (TypeInfo *tyinfo, Archive *fout)
static void	selectDumpableDefaultACL (DefaultACLInfo *dinfo, DumpOptions *dopt)
static void	selectDumpableCast (CastInfo *cast, Archive *fout)
static void	selectDumpableProcLang (ProcLangInfo *plang, Archive *fout)
static void	selectDumpableAccessMethod (AccessMethodInfo *method, Archive *fout)
static void	selectDumpableExtension (ExtensionInfo *extinfo, DumpOptions *dopt)
static void	selectDumpablePublicationObject (DumpableObject *dobj, Archive *fout)
static void	selectDumpableObject (DumpableObject *dobj, Archive *fout)
static int	dumpTableData_copy (Archive *fout, const void *dcontext)
static int	dumpTableData_insert (Archive *fout, const void *dcontext)
void	getPolicies (Archive *fout, TableInfo tblinfo[], int numTables)
PublicationInfo *	getPublications (Archive *fout, int *numPublications)
void	getPublicationNamespaces (Archive *fout)
void	getPublicationTables (Archive *fout, TableInfo tblinfo[], int numTables)
static void	dumpPublicationNamespace (Archive *fout, const PublicationSchemaInfo *pubsinfo)
static bool	is_superuser (Archive *fout)
void	getSubscriptions (Archive *fout)
static void	append_depends_on_extension (Archive *fout, PQExpBuffer create, const DumpableObject *dobj, const char *catalog, const char *keyword, const char *objname)
static Oid	get_next_possible_free_pg_type_oid (Archive *fout, PQExpBuffer upgrade_query)
NamespaceInfo *	getNamespaces (Archive *fout, int *numNamespaces)
ExtensionInfo *	getExtensions (Archive *fout, int *numExtensions)
TypeInfo *	getTypes (Archive *fout, int *numTypes)
OprInfo *	getOperators (Archive *fout, int *numOprs)
CollInfo *	getCollations (Archive *fout, int *numCollations)
ConvInfo *	getConversions (Archive *fout, int *numConversions)
AccessMethodInfo *	getAccessMethods (Archive *fout, int *numAccessMethods)
OpclassInfo *	getOpclasses (Archive *fout, int *numOpclasses)
OpfamilyInfo *	getOpfamilies (Archive *fout, int *numOpfamilies)
AggInfo *	getAggregates (Archive *fout, int *numAggs)
FuncInfo *	getFuncs (Archive *fout, int *numFuncs)
TableInfo *	getTables (Archive *fout, int *numTables)
void	getOwnedSeqs (Archive *fout, TableInfo tblinfo[], int numTables)
InhInfo *	getInherits (Archive *fout, int *numInherits)
void	getPartitioningInfo (Archive *fout)
void	getIndexes (Archive *fout, TableInfo tblinfo[], int numTables)
void	getExtendedStatistics (Archive *fout)
void	getConstraints (Archive *fout, TableInfo tblinfo[], int numTables)
RuleInfo *	getRules (Archive *fout, int *numRules)
void	getTriggers (Archive *fout, TableInfo tblinfo[], int numTables)
EventTriggerInfo *	getEventTriggers (Archive *fout, int *numEventTriggers)
ProcLangInfo *	getProcLangs (Archive *fout, int *numProcLangs)
CastInfo *	getCasts (Archive *fout, int *numCasts)
static char *	get_language_name (Archive *fout, Oid langid)
TransformInfo *	getTransforms (Archive *fout, int *numTransforms)
void	getTableAttrs (Archive *fout, TableInfo *tblinfo, int numTables)
bool	shouldPrintColumn (const DumpOptions *dopt, const TableInfo *tbinfo, int colno)
TSParserInfo *	getTSParsers (Archive *fout, int *numTSParsers)
TSDictInfo *	getTSDictionaries (Archive *fout, int *numTSDicts)
TSTemplateInfo *	getTSTemplates (Archive *fout, int *numTSTemplates)
TSConfigInfo *	getTSConfigurations (Archive *fout, int *numTSConfigs)
FdwInfo *	getForeignDataWrappers (Archive *fout, int *numForeignDataWrappers)
ForeignServerInfo *	getForeignServers (Archive *fout, int *numForeignServers)
DefaultACLInfo *	getDefaultACLs (Archive *fout, int *numDefaultACLs)
static void	dumpTableComment (Archive *fout, const TableInfo *tbinfo, const char *reltypename)
static char *	format_aggregate_signature (const AggInfo *agginfo, Archive *fout, bool honor_quotes)
static void	dumpTableSecLabel (Archive *fout, const TableInfo *tbinfo, const char *reltypename)
static PQExpBuffer	createViewAsClause (Archive *fout, const TableInfo *tbinfo)
static PQExpBuffer	createDummyViewAsClause (Archive *fout, const TableInfo *tbinfo)
void	getExtensionMembership (Archive *fout, ExtensionInfo extinfo[], int numExtensions)
void	processExtensionTables (Archive *fout, ExtensionInfo extinfo[], int numExtensions)

Variables
static bool	dosync = true
static Oid	g_last_builtin_oid
static int	strict_names = 0
static pg_compress_algorithm	compression_algorithm = PG_COMPRESSION_NONE
static SimpleStringList	schema_include_patterns = {NULL, NULL}
static SimpleOidList	schema_include_oids = {NULL, NULL}
static SimpleStringList	schema_exclude_patterns = {NULL, NULL}
static SimpleOidList	schema_exclude_oids = {NULL, NULL}
static SimpleStringList	table_include_patterns = {NULL, NULL}
static SimpleStringList	table_include_patterns_and_children = {NULL, NULL}
static SimpleOidList	table_include_oids = {NULL, NULL}
static SimpleStringList	table_exclude_patterns = {NULL, NULL}
static SimpleStringList	table_exclude_patterns_and_children = {NULL, NULL}
static SimpleOidList	table_exclude_oids = {NULL, NULL}
static SimpleStringList	tabledata_exclude_patterns = {NULL, NULL}
static SimpleStringList	tabledata_exclude_patterns_and_children = {NULL, NULL}
static SimpleOidList	tabledata_exclude_oids = {NULL, NULL}
static SimpleStringList	foreign_servers_include_patterns = {NULL, NULL}
static SimpleOidList	foreign_servers_include_oids = {NULL, NULL}
static SimpleStringList	extension_include_patterns = {NULL, NULL}
static SimpleOidList	extension_include_oids = {NULL, NULL}
static const CatalogId	nilCatalogId = {0, 0}
static bool	have_extra_float_digits = false
static int	extra_float_digits
static RoleNameItem *	rolenames = NULL
static int	nrolenames = 0
static CommentItem *	comments = NULL
static int	ncomments = 0
static SecLabelItem *	seclabels = NULL
static int	nseclabels = 0

Macro Definition Documentation

DUMP_DEFAULT_ROWS_PER_INSERT

#define DUMP_DEFAULT_ROWS_PER_INSERT   1

Definition at line 160 of file pg_dump.c.

fmtQualifiedDumpable

#define fmtQualifiedDumpable

(

obj

)

Value:

    fmtQualifiedId((obj)->dobj.namespace->dobj.name, \
                   (obj)->dobj.name)

Definition at line 165 of file pg_dump.c.

Typedef Documentation

OidOptions

typedef enum OidOptions OidOptions

Enumeration Type Documentation

OidOptions

enum OidOptions

Enumerator
zeroIsError
zeroAsStar
zeroAsNone

Definition at line 94 of file pg_dump.c.

{
    zeroIsError = 1,
    zeroAsStar = 2,
    zeroAsNone = 4
} OidOptions;

Function Documentation

addBoundaryDependencies()

static void addBoundaryDependencies ( DumpableObject **  dobjs, int  numObjs, DumpableObject *  boundaryObjs  )

static

Definition at line 18429 of file pg_dump.c.

{
    DumpableObject *preDataBound = boundaryObjs + 0;
    DumpableObject *postDataBound = boundaryObjs + 1;
    int         i;
 
    for (i = 0; i < numObjs; i++)
    {
        DumpableObject *dobj = dobjs[i];
 
        /*
         * The classification of object types here must match the SECTION_xxx
         * values assigned during subsequent ArchiveEntry calls!
         */
        switch (dobj->objType)
        {
            case DO_NAMESPACE:
            case DO_EXTENSION:
            case DO_TYPE:
            case DO_SHELL_TYPE:
            case DO_FUNC:
            case DO_AGG:
            case DO_OPERATOR:
            case DO_ACCESS_METHOD:
            case DO_OPCLASS:
            case DO_OPFAMILY:
            case DO_COLLATION:
            case DO_CONVERSION:
            case DO_TABLE:
            case DO_TABLE_ATTACH:
            case DO_ATTRDEF:
            case DO_PROCLANG:
            case DO_CAST:
            case DO_DUMMY_TYPE:
            case DO_TSPARSER:
            case DO_TSDICT:
            case DO_TSTEMPLATE:
            case DO_TSCONFIG:
            case DO_FDW:
            case DO_FOREIGN_SERVER:
            case DO_TRANSFORM:
            case DO_LARGE_OBJECT:
                /* Pre-data objects: must come before the pre-data boundary */
                addObjectDependency(preDataBound, dobj->dumpId);
                break;
            case DO_TABLE_DATA:
            case DO_SEQUENCE_SET:
            case DO_LARGE_OBJECT_DATA:
                /* Data objects: must come between the boundaries */
                addObjectDependency(dobj, preDataBound->dumpId);
                addObjectDependency(postDataBound, dobj->dumpId);
                break;
            case DO_INDEX:
            case DO_INDEX_ATTACH:
            case DO_STATSEXT:
            case DO_REFRESH_MATVIEW:
            case DO_TRIGGER:
            case DO_EVENT_TRIGGER:
            case DO_DEFAULT_ACL:
            case DO_POLICY:
            case DO_PUBLICATION:
            case DO_PUBLICATION_REL:
            case DO_PUBLICATION_TABLE_IN_SCHEMA:
            case DO_SUBSCRIPTION:
                /* Post-data objects: must come after the post-data boundary */
                addObjectDependency(dobj, postDataBound->dumpId);
                break;
            case DO_RULE:
                /* Rules are post-data, but only if dumped separately */
                if (((RuleInfo *) dobj)->separate)
                    addObjectDependency(dobj, postDataBound->dumpId);
                break;
            case DO_CONSTRAINT:
            case DO_FK_CONSTRAINT:
                /* Constraints are post-data, but only if dumped separately */
                if (((ConstraintInfo *) dobj)->separate)
                    addObjectDependency(dobj, postDataBound->dumpId);
                break;
            case DO_PRE_DATA_BOUNDARY:
                /* nothing to do */
                break;
            case DO_POST_DATA_BOUNDARY:
                /* must come after the pre-data boundary */
                addObjectDependency(dobj, preDataBound->dumpId);
                break;
        }
    }
}

References addObjectDependency(), DO_ACCESS_METHOD, DO_AGG, DO_ATTRDEF, DO_CAST, DO_COLLATION, DO_CONSTRAINT, DO_CONVERSION, DO_DEFAULT_ACL, DO_DUMMY_TYPE, DO_EVENT_TRIGGER, DO_EXTENSION, DO_FDW, DO_FK_CONSTRAINT, DO_FOREIGN_SERVER, DO_FUNC, DO_INDEX, DO_INDEX_ATTACH, DO_LARGE_OBJECT, DO_LARGE_OBJECT_DATA, DO_NAMESPACE, DO_OPCLASS, DO_OPERATOR, DO_OPFAMILY, DO_POLICY, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, DO_PROCLANG, DO_PUBLICATION, DO_PUBLICATION_REL, DO_PUBLICATION_TABLE_IN_SCHEMA, DO_REFRESH_MATVIEW, DO_RULE, DO_SEQUENCE_SET, DO_SHELL_TYPE, DO_STATSEXT, DO_SUBSCRIPTION, DO_TABLE, DO_TABLE_ATTACH, DO_TABLE_DATA, DO_TRANSFORM, DO_TRIGGER, DO_TSCONFIG, DO_TSDICT, DO_TSPARSER, DO_TSTEMPLATE, DO_TYPE, _dumpableObject::dumpId, i, and _dumpableObject::objType.

Referenced by main().

addConstrChildIdxDeps()

static void addConstrChildIdxDeps ( DumpableObject *  dobj, const IndxInfo *  refidx  )

static

Definition at line 7492 of file pg_dump.c.

{
    SimplePtrListCell *cell;
 
    Assert(dobj->objType == DO_FK_CONSTRAINT);
 
    for (cell = refidx->partattaches.head; cell; cell = cell->next)
    {
        IndexAttachInfo *attach = (IndexAttachInfo *) cell->ptr;
 
        addObjectDependency(dobj, attach->dobj.dumpId);
 
        if (attach->partitionIdx->partattaches.head != NULL)
            addConstrChildIdxDeps(dobj, attach->partitionIdx);
    }
}

References addObjectDependency(), Assert(), DO_FK_CONSTRAINT, _indexAttachInfo::dobj, _dumpableObject::dumpId, SimplePtrList::head, SimplePtrListCell::next, _dumpableObject::objType, _indxInfo::partattaches, _indexAttachInfo::partitionIdx, and SimplePtrListCell::ptr.

Referenced by getConstraints().

append_depends_on_extension()

static void append_depends_on_extension ( Archive *  fout, PQExpBuffer  create, const DumpableObject *  dobj, const char *  catalog, const char *  keyword, const char *  objname  )

static

Definition at line 4842 of file pg_dump.c.

{
    if (dobj->depends_on_ext)
    {
        char       *nm;
        PGresult   *res;
        PQExpBuffer query;
        int         ntups;
        int         i_extname;
        int         i;
 
        /* dodge fmtId() non-reentrancy */
        nm = pg_strdup(objname);
 
        query = createPQExpBuffer();
        appendPQExpBuffer(query,
                          "SELECT e.extname "
                          "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
                          "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
                          "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
                          "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
                          catalog,
                          dobj->catId.oid);
        res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
        ntups = PQntuples(res);
        i_extname = PQfnumber(res, "extname");
        for (i = 0; i < ntups; i++)
        {
            appendPQExpBuffer(create, "\nALTER %s %s DEPENDS ON EXTENSION %s;",
                              keyword, nm,
                              fmtId(PQgetvalue(res, i, i_extname)));
        }
 
        PQclear(res);
        destroyPQExpBuffer(query);
        pg_free(nm);
    }
}

References appendPQExpBuffer(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpableObject::depends_on_ext, destroyPQExpBuffer(), ExecuteSqlQuery(), fmtId(), i, CatalogId::oid, pg_free(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), and res.

Referenced by dumpConstraint(), dumpFunc(), dumpIndex(), dumpTableSchema(), and dumpTrigger().

appendReloptionsArrayAH()

static void appendReloptionsArrayAH ( PQExpBuffer  buffer, const char *  reloptions, const char *  prefix, Archive *  fout  )

static

Definition at line 18745 of file pg_dump.c.

{
    bool        res;
 
    res = appendReloptionsArray(buffer, reloptions, prefix, fout->encoding,
                                fout->std_strings);
    if (!res)
        pg_log_warning("could not parse %s array", "reloptions");
}

References appendReloptionsArray(), Archive::encoding, pg_log_warning, res, and Archive::std_strings.

Referenced by dumpConstraint(), dumpRule(), and dumpTableSchema().

binary_upgrade_extension_member()

static void binary_upgrade_extension_member ( PQExpBuffer  upgrade_buffer, const DumpableObject *  dobj, const char *  objtype, const char *  objname, const char *  objnamespace  )

static

Definition at line 5131 of file pg_dump.c.

{
    DumpableObject *extobj = NULL;
    int         i;
 
    if (!dobj->ext_member)
        return;
 
    /*
     * Find the parent extension.  We could avoid this search if we wanted to
     * add a link field to DumpableObject, but the space costs of that would
     * be considerable.  We assume that member objects could only have a
     * direct dependency on their own extension, not any others.
     */
    for (i = 0; i < dobj->nDeps; i++)
    {
        extobj = findObjectByDumpId(dobj->dependencies[i]);
        if (extobj && extobj->objType == DO_EXTENSION)
            break;
        extobj = NULL;
    }
    if (extobj == NULL)
        pg_fatal("could not find parent extension for %s %s",
                 objtype, objname);
 
    appendPQExpBufferStr(upgrade_buffer,
                         "\n-- For binary upgrade, handle extension membership the hard way\n");
    appendPQExpBuffer(upgrade_buffer, "ALTER EXTENSION %s ADD %s ",
                      fmtId(extobj->name),
                      objtype);
    if (objnamespace && *objnamespace)
        appendPQExpBuffer(upgrade_buffer, "%s.", fmtId(objnamespace));
    appendPQExpBuffer(upgrade_buffer, "%s;\n", objname);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), _dumpableObject::dependencies, DO_EXTENSION, _dumpableObject::ext_member, findObjectByDumpId(), fmtId(), i, _dumpableObject::name, _dumpableObject::nDeps, _dumpableObject::objType, and pg_fatal.

Referenced by dumpAccessMethod(), dumpAgg(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpConversion(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpProcLang(), dumpRangeType(), dumpSequence(), dumpTableSchema(), dumpTransform(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), and dumpUndefinedType().

binary_upgrade_set_pg_class_oids()

static void binary_upgrade_set_pg_class_oids ( Archive *  fout, PQExpBuffer  upgrade_buffer, Oid  pg_class_oid, bool  is_index  )

static

Definition at line 5015 of file pg_dump.c.

{
    PQExpBuffer upgrade_query = createPQExpBuffer();
    PGresult   *upgrade_res;
    RelFileNumber relfilenumber;
    Oid         toast_oid;
    RelFileNumber toast_relfilenumber;
    char        relkind;
    Oid         toast_index_oid;
    RelFileNumber toast_index_relfilenumber;
 
    /*
     * Preserve the OID and relfilenumber of the table, table's index, table's
     * toast table and toast table's index if any.
     *
     * One complexity is that the current table definition might not require
     * the creation of a TOAST table, but the old database might have a TOAST
     * table that was created earlier, before some wide columns were dropped.
     * By setting the TOAST oid we force creation of the TOAST heap and index
     * by the new backend, so we can copy the files during binary upgrade
     * without worrying about this case.
     */
    appendPQExpBuffer(upgrade_query,
                      "SELECT c.relkind, c.relfilenode, c.reltoastrelid, ct.relfilenode AS toast_relfilenode, i.indexrelid, cti.relfilenode AS toast_index_relfilenode "
                      "FROM pg_catalog.pg_class c LEFT JOIN "
                      "pg_catalog.pg_index i ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
                      "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
                      "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
                      "WHERE c.oid = '%u'::pg_catalog.oid;",
                      pg_class_oid);
 
    upgrade_res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);
 
    relkind = *PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "relkind"));
 
    relfilenumber = atooid(PQgetvalue(upgrade_res, 0,
                                      PQfnumber(upgrade_res, "relfilenode")));
    toast_oid = atooid(PQgetvalue(upgrade_res, 0,
                                  PQfnumber(upgrade_res, "reltoastrelid")));
    toast_relfilenumber = atooid(PQgetvalue(upgrade_res, 0,
                                            PQfnumber(upgrade_res, "toast_relfilenode")));
    toast_index_oid = atooid(PQgetvalue(upgrade_res, 0,
                                        PQfnumber(upgrade_res, "indexrelid")));
    toast_index_relfilenumber = atooid(PQgetvalue(upgrade_res, 0,
                                                  PQfnumber(upgrade_res, "toast_index_relfilenode")));
 
    appendPQExpBufferStr(upgrade_buffer,
                         "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
 
    if (!is_index)
    {
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
                          pg_class_oid);
 
        /*
         * Not every relation has storage. Also, in a pre-v12 database,
         * partitioned tables have a relfilenumber, which should not be
         * preserved when upgrading.
         */
        if (RelFileNumberIsValid(relfilenumber) && relkind != RELKIND_PARTITIONED_TABLE)
            appendPQExpBuffer(upgrade_buffer,
                              "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
                              relfilenumber);
 
        /*
         * In a pre-v12 database, partitioned tables might be marked as having
         * toast tables, but we should ignore them if so.
         */
        if (OidIsValid(toast_oid) &&
            relkind != RELKIND_PARTITIONED_TABLE)
        {
            appendPQExpBuffer(upgrade_buffer,
                              "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
                              toast_oid);
            appendPQExpBuffer(upgrade_buffer,
                              "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
                              toast_relfilenumber);
 
            /* every toast table has an index */
            appendPQExpBuffer(upgrade_buffer,
                              "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
                              toast_index_oid);
            appendPQExpBuffer(upgrade_buffer,
                              "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
                              toast_index_relfilenumber);
        }
 
        PQclear(upgrade_res);
    }
    else
    {
        /* Preserve the OID and relfilenumber of the index */
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
                          pg_class_oid);
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
                          relfilenumber);
    }
 
    appendPQExpBufferChar(upgrade_buffer, '\n');
 
    destroyPQExpBuffer(upgrade_query);
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), OidIsValid, PQclear(), PQfnumber(), PQgetvalue(), and RelFileNumberIsValid.

Referenced by dumpCompositeType(), dumpConstraint(), dumpIndex(), dumpSequence(), and dumpTableSchema().

binary_upgrade_set_type_oids_by_rel()

static void binary_upgrade_set_type_oids_by_rel ( Archive *  fout, PQExpBuffer  upgrade_buffer, const TableInfo *  tbinfo  )

static

Definition at line 5003 of file pg_dump.c.

{
    Oid         pg_type_oid = tbinfo->reltype;
 
    if (OidIsValid(pg_type_oid))
        binary_upgrade_set_type_oids_by_type_oid(fout, upgrade_buffer,
                                                 pg_type_oid, false, false);
}

References binary_upgrade_set_type_oids_by_type_oid(), OidIsValid, and _tableInfo::reltype.

Referenced by dumpTableSchema().

binary_upgrade_set_type_oids_by_type_oid()

static void binary_upgrade_set_type_oids_by_type_oid ( Archive *  fout, PQExpBuffer  upgrade_buffer, Oid  pg_type_oid, bool  force_array_type, bool  include_multirange_type  )

static

Definition at line 4918 of file pg_dump.c.

{
    PQExpBuffer upgrade_query = createPQExpBuffer();
    PGresult   *res;
    Oid         pg_type_array_oid;
    Oid         pg_type_multirange_oid;
    Oid         pg_type_multirange_array_oid;
 
    appendPQExpBufferStr(upgrade_buffer, "\n-- For binary upgrade, must preserve pg_type oid\n");
    appendPQExpBuffer(upgrade_buffer,
                      "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                      pg_type_oid);
 
    appendPQExpBuffer(upgrade_query,
                      "SELECT typarray "
                      "FROM pg_catalog.pg_type "
                      "WHERE oid = '%u'::pg_catalog.oid;",
                      pg_type_oid);
 
    res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);
 
    pg_type_array_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typarray")));
 
    PQclear(res);
 
    if (!OidIsValid(pg_type_array_oid) && force_array_type)
        pg_type_array_oid = get_next_possible_free_pg_type_oid(fout, upgrade_query);
 
    if (OidIsValid(pg_type_array_oid))
    {
        appendPQExpBufferStr(upgrade_buffer,
                             "\n-- For binary upgrade, must preserve pg_type array oid\n");
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                          pg_type_array_oid);
    }
 
    /*
     * Pre-set the multirange type oid and its own array type oid.
     */
    if (include_multirange_type)
    {
        if (fout->remoteVersion >= 140000)
        {
            printfPQExpBuffer(upgrade_query,
                              "SELECT t.oid, t.typarray "
                              "FROM pg_catalog.pg_type t "
                              "JOIN pg_catalog.pg_range r "
                              "ON t.oid = r.rngmultitypid "
                              "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
                              pg_type_oid);
 
            res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);
 
            pg_type_multirange_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "oid")));
            pg_type_multirange_array_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typarray")));
 
            PQclear(res);
        }
        else
        {
            pg_type_multirange_oid = get_next_possible_free_pg_type_oid(fout, upgrade_query);
            pg_type_multirange_array_oid = get_next_possible_free_pg_type_oid(fout, upgrade_query);
        }
 
        appendPQExpBufferStr(upgrade_buffer,
                             "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                          pg_type_multirange_oid);
        appendPQExpBufferStr(upgrade_buffer,
                             "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                          pg_type_multirange_array_oid);
    }
 
    destroyPQExpBuffer(upgrade_query);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), get_next_possible_free_pg_type_oid(), OidIsValid, PQclear(), PQfnumber(), PQgetvalue(), printfPQExpBuffer(), Archive::remoteVersion, and res.

Referenced by binary_upgrade_set_type_oids_by_rel(), dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpRangeType(), dumpShellType(), and dumpUndefinedType().

BuildArchiveDependencies()

static void BuildArchiveDependencies ( Archive *  fout )

static

Definition at line 18544 of file pg_dump.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) fout;
    TocEntry   *te;
 
    /* Scan all TOC entries in the archive */
    for (te = AH->toc->next; te != AH->toc; te = te->next)
    {
        DumpableObject *dobj;
        DumpId     *dependencies;
        int         nDeps;
        int         allocDeps;
 
        /* No need to process entries that will not be dumped */
        if (te->reqs == 0)
            continue;
        /* Ignore entries that already have "special" dependencies */
        if (te->nDeps > 0)
            continue;
        /* Otherwise, look up the item's original DumpableObject, if any */
        dobj = findObjectByDumpId(te->dumpId);
        if (dobj == NULL)
            continue;
        /* No work if it has no dependencies */
        if (dobj->nDeps <= 0)
            continue;
        /* Set up work array */
        allocDeps = 64;
        dependencies = (DumpId *) pg_malloc(allocDeps * sizeof(DumpId));
        nDeps = 0;
        /* Recursively find all dumpable dependencies */
        findDumpableDependencies(AH, dobj,
                                 &dependencies, &nDeps, &allocDeps);
        /* And save 'em ... */
        if (nDeps > 0)
        {
            dependencies = (DumpId *) pg_realloc(dependencies,
                                                 nDeps * sizeof(DumpId));
            te->dependencies = dependencies;
            te->nDeps = nDeps;
        }
        else
            free(dependencies);
    }
}

References _tocEntry::dependencies, _tocEntry::dumpId, findDumpableDependencies(), findObjectByDumpId(), free, _tocEntry::nDeps, _dumpableObject::nDeps, _tocEntry::next, pg_malloc(), pg_realloc(), _tocEntry::reqs, and _archiveHandle::toc.

Referenced by main().

buildMatViewRefreshDependencies()

static void buildMatViewRefreshDependencies ( Archive *  fout )

static

Definition at line 2780 of file pg_dump.c.

{
    PQExpBuffer query;
    PGresult   *res;
    int         ntups,
                i;
    int         i_classid,
                i_objid,
                i_refobjid;
 
    /* No Mat Views before 9.3. */
    if (fout->remoteVersion < 90300)
        return;
 
    query = createPQExpBuffer();
 
    appendPQExpBufferStr(query, "WITH RECURSIVE w AS "
                         "( "
                         "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
                         "FROM pg_depend d1 "
                         "JOIN pg_class c1 ON c1.oid = d1.objid "
                         "AND c1.relkind = " CppAsString2(RELKIND_MATVIEW)
                         " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
                         "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
                         "AND d2.objid = r1.oid "
                         "AND d2.refobjid <> d1.objid "
                         "JOIN pg_class c2 ON c2.oid = d2.refobjid "
                         "AND c2.relkind IN (" CppAsString2(RELKIND_MATVIEW) ","
                         CppAsString2(RELKIND_VIEW) ") "
                         "WHERE d1.classid = 'pg_class'::regclass "
                         "UNION "
                         "SELECT w.objid, d3.refobjid, c3.relkind "
                         "FROM w "
                         "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
                         "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
                         "AND d3.objid = r3.oid "
                         "AND d3.refobjid <> w.refobjid "
                         "JOIN pg_class c3 ON c3.oid = d3.refobjid "
                         "AND c3.relkind IN (" CppAsString2(RELKIND_MATVIEW) ","
                         CppAsString2(RELKIND_VIEW) ") "
                         ") "
                         "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
                         "FROM w "
                         "WHERE refrelkind = " CppAsString2(RELKIND_MATVIEW));
 
    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
 
    ntups = PQntuples(res);
 
    i_classid = PQfnumber(res, "classid");
    i_objid = PQfnumber(res, "objid");
    i_refobjid = PQfnumber(res, "refobjid");
 
    for (i = 0; i < ntups; i++)
    {
        CatalogId   objId;
        CatalogId   refobjId;
        DumpableObject *dobj;
        DumpableObject *refdobj;
        TableInfo  *tbinfo;
        TableInfo  *reftbinfo;
 
        objId.tableoid = atooid(PQgetvalue(res, i, i_classid));
        objId.oid = atooid(PQgetvalue(res, i, i_objid));
        refobjId.tableoid = objId.tableoid;
        refobjId.oid = atooid(PQgetvalue(res, i, i_refobjid));
 
        dobj = findObjectByCatalogId(objId);
        if (dobj == NULL)
            continue;
 
        Assert(dobj->objType == DO_TABLE);
        tbinfo = (TableInfo *) dobj;
        Assert(tbinfo->relkind == RELKIND_MATVIEW);
        dobj = (DumpableObject *) tbinfo->dataObj;
        if (dobj == NULL)
            continue;
        Assert(dobj->objType == DO_REFRESH_MATVIEW);
 
        refdobj = findObjectByCatalogId(refobjId);
        if (refdobj == NULL)
            continue;
 
        Assert(refdobj->objType == DO_TABLE);
        reftbinfo = (TableInfo *) refdobj;
        Assert(reftbinfo->relkind == RELKIND_MATVIEW);
        refdobj = (DumpableObject *) reftbinfo->dataObj;
        if (refdobj == NULL)
            continue;
        Assert(refdobj->objType == DO_REFRESH_MATVIEW);
 
        addObjectDependency(dobj, refdobj->dumpId);
 
        if (!reftbinfo->relispopulated)
            tbinfo->relispopulated = false;
    }
 
    PQclear(res);
 
    destroyPQExpBuffer(query);
}

References addObjectDependency(), appendPQExpBufferStr(), Assert(), atooid, CppAsString2, createPQExpBuffer(), PQExpBufferData::data, _tableInfo::dataObj, destroyPQExpBuffer(), DO_REFRESH_MATVIEW, DO_TABLE, _dumpableObject::dumpId, ExecuteSqlQuery(), findObjectByCatalogId(), i, if(), _dumpableObject::objType, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _tableInfo::relispopulated, _tableInfo::relkind, Archive::remoteVersion, res, and CatalogId::tableoid.

Referenced by main().

checkExtensionMembership()

static bool checkExtensionMembership ( DumpableObject *  dobj, Archive *  fout  )

static

Definition at line 1670 of file pg_dump.c.

{
    ExtensionInfo *ext = findOwningExtension(dobj->catId);
 
    if (ext == NULL)
        return false;
 
    dobj->ext_member = true;
 
    /* Record dependency so that getDependencies needn't deal with that */
    addObjectDependency(dobj, ext->dobj.dumpId);
 
    /*
     * In 9.6 and above, mark the member object to have any non-initial ACL,
     * policies, and security labels dumped.
     *
     * Note that any initial ACLs (see pg_init_privs) will be removed when we
     * extract the information about the object.  We don't provide support for
     * initial policies and security labels and it seems unlikely for those to
     * ever exist, but we may have to revisit this later.
     *
     * Prior to 9.6, we do not include any extension member components.
     *
     * In binary upgrades, we still dump all components of the members
     * individually, since the idea is to exactly reproduce the database
     * contents rather than replace the extension contents with something
     * different.
     */
    if (fout->dopt->binary_upgrade)
        dobj->dump = ext->dobj.dump;
    else
    {
        if (fout->remoteVersion < 90600)
            dobj->dump = DUMP_COMPONENT_NONE;
        else
            dobj->dump = ext->dobj.dump_contains & (DUMP_COMPONENT_ACL |
                                                    DUMP_COMPONENT_SECLABEL |
                                                    DUMP_COMPONENT_POLICY);
    }
 
    return true;
}

References addObjectDependency(), _dumpOptions::binary_upgrade, _dumpableObject::catId, _extensionInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_NONE, DUMP_COMPONENT_POLICY, DUMP_COMPONENT_SECLABEL, _dumpableObject::dump_contains, _dumpableObject::dumpId, _dumpableObject::ext_member, findOwningExtension(), and Archive::remoteVersion.

Referenced by selectDumpableAccessMethod(), selectDumpableCast(), selectDumpableNamespace(), selectDumpableObject(), selectDumpableProcLang(), selectDumpablePublicationObject(), selectDumpableTable(), and selectDumpableType().

collectComments()

static void collectComments ( Archive *  fout )

static

Definition at line 10171 of file pg_dump.c.

{
    PGresult   *res;
    PQExpBuffer query;
    int         i_description;
    int         i_classoid;
    int         i_objoid;
    int         i_objsubid;
    int         ntups;
    int         i;
    DumpableObject *dobj;
 
    query = createPQExpBuffer();
 
    appendPQExpBufferStr(query, "SELECT description, classoid, objoid, objsubid "
                         "FROM pg_catalog.pg_description "
                         "ORDER BY classoid, objoid, objsubid");
 
    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
 
    /* Construct lookup table containing OIDs in numeric form */
 
    i_description = PQfnumber(res, "description");
    i_classoid = PQfnumber(res, "classoid");
    i_objoid = PQfnumber(res, "objoid");
    i_objsubid = PQfnumber(res, "objsubid");
 
    ntups = PQntuples(res);
 
    comments = (CommentItem *) pg_malloc(ntups * sizeof(CommentItem));
    ncomments = 0;
    dobj = NULL;
 
    for (i = 0; i < ntups; i++)
    {
        CatalogId   objId;
        int         subid;
 
        objId.tableoid = atooid(PQgetvalue(res, i, i_classoid));
        objId.oid = atooid(PQgetvalue(res, i, i_objoid));
        subid = atoi(PQgetvalue(res, i, i_objsubid));
 
        /* We needn't remember comments that don't match any dumpable object */
        if (dobj == NULL ||
            dobj->catId.tableoid != objId.tableoid ||
            dobj->catId.oid != objId.oid)
            dobj = findObjectByCatalogId(objId);
        if (dobj == NULL)
            continue;
 
        /*
         * Comments on columns of composite types are linked to the type's
         * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
         * in the type's own DumpableObject.
         */
        if (subid != 0 && dobj->objType == DO_TABLE &&
            ((TableInfo *) dobj)->relkind == RELKIND_COMPOSITE_TYPE)
        {
            TypeInfo   *cTypeInfo;
 
            cTypeInfo = findTypeByOid(((TableInfo *) dobj)->reltype);
            if (cTypeInfo)
                cTypeInfo->dobj.components |= DUMP_COMPONENT_COMMENT;
        }
        else
            dobj->components |= DUMP_COMPONENT_COMMENT;
 
        comments[ncomments].descr = pg_strdup(PQgetvalue(res, i, i_description));
        comments[ncomments].classoid = objId.tableoid;
        comments[ncomments].objoid = objId.oid;
        comments[ncomments].objsubid = subid;
        ncomments++;
    }
 
    PQclear(res);
    destroyPQExpBuffer(query);
}

References appendPQExpBufferStr(), atooid, _dumpableObject::catId, CommentItem::classoid, comments, _dumpableObject::components, createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), DO_TABLE, _typeInfo::dobj, DUMP_COMPONENT_COMMENT, ExecuteSqlQuery(), findObjectByCatalogId(), findTypeByOid(), i, ncomments, CommentItem::objoid, CommentItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), res, and CatalogId::tableoid.

Referenced by main().

collectRoleNames()

static void collectRoleNames ( Archive *  fout )

static

Definition at line 9716 of file pg_dump.c.

{
    PGresult   *res;
    const char *query;
    int         i;
 
    query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
 
    res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK);
 
    nrolenames = PQntuples(res);
 
    rolenames = (RoleNameItem *) pg_malloc(nrolenames * sizeof(RoleNameItem));
 
    for (i = 0; i < nrolenames; i++)
    {
        rolenames[i].roleoid = atooid(PQgetvalue(res, i, 0));
        rolenames[i].rolename = pg_strdup(PQgetvalue(res, i, 1));
    }
 
    PQclear(res);
}

References atooid, ExecuteSqlQuery(), i, nrolenames, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), res, RoleNameItem::rolename, rolenames, and RoleNameItem::roleoid.

Referenced by main().

collectSecLabels()

static void collectSecLabels ( Archive *  fout )

static

Definition at line 15286 of file pg_dump.c.

{
    PGresult   *res;
    PQExpBuffer query;
    int         i_label;
    int         i_provider;
    int         i_classoid;
    int         i_objoid;
    int         i_objsubid;
    int         ntups;
    int         i;
    DumpableObject *dobj;
 
    query = createPQExpBuffer();
 
    appendPQExpBufferStr(query,
                         "SELECT label, provider, classoid, objoid, objsubid "
                         "FROM pg_catalog.pg_seclabel "
                         "ORDER BY classoid, objoid, objsubid");
 
    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
 
    /* Construct lookup table containing OIDs in numeric form */
    i_label = PQfnumber(res, "label");
    i_provider = PQfnumber(res, "provider");
    i_classoid = PQfnumber(res, "classoid");
    i_objoid = PQfnumber(res, "objoid");
    i_objsubid = PQfnumber(res, "objsubid");
 
    ntups = PQntuples(res);
 
    seclabels = (SecLabelItem *) pg_malloc(ntups * sizeof(SecLabelItem));
    nseclabels = 0;
    dobj = NULL;
 
    for (i = 0; i < ntups; i++)
    {
        CatalogId   objId;
        int         subid;
 
        objId.tableoid = atooid(PQgetvalue(res, i, i_classoid));
        objId.oid = atooid(PQgetvalue(res, i, i_objoid));
        subid = atoi(PQgetvalue(res, i, i_objsubid));
 
        /* We needn't remember labels that don't match any dumpable object */
        if (dobj == NULL ||
            dobj->catId.tableoid != objId.tableoid ||
            dobj->catId.oid != objId.oid)
            dobj = findObjectByCatalogId(objId);
        if (dobj == NULL)
            continue;
 
        /*
         * Labels on columns of composite types are linked to the type's
         * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
         * in the type's own DumpableObject.
         */
        if (subid != 0 && dobj->objType == DO_TABLE &&
            ((TableInfo *) dobj)->relkind == RELKIND_COMPOSITE_TYPE)
        {
            TypeInfo   *cTypeInfo;
 
            cTypeInfo = findTypeByOid(((TableInfo *) dobj)->reltype);
            if (cTypeInfo)
                cTypeInfo->dobj.components |= DUMP_COMPONENT_SECLABEL;
        }
        else
            dobj->components |= DUMP_COMPONENT_SECLABEL;
 
        seclabels[nseclabels].label = pg_strdup(PQgetvalue(res, i, i_label));
        seclabels[nseclabels].provider = pg_strdup(PQgetvalue(res, i, i_provider));
        seclabels[nseclabels].classoid = objId.tableoid;
        seclabels[nseclabels].objoid = objId.oid;
        seclabels[nseclabels].objsubid = subid;
        nseclabels++;
    }
 
    PQclear(res);
    destroyPQExpBuffer(query);
}

References appendPQExpBufferStr(), atooid, _dumpableObject::catId, SecLabelItem::classoid, _dumpableObject::components, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TABLE, _typeInfo::dobj, DUMP_COMPONENT_SECLABEL, ExecuteSqlQuery(), findObjectByCatalogId(), findTypeByOid(), i, SecLabelItem::label, nseclabels, SecLabelItem::objoid, SecLabelItem::objsubid, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), SecLabelItem::provider, res, seclabels, and CatalogId::tableoid.

Referenced by main().

convertRegProcReference()

static char * convertRegProcReference ( const char *  proc )

static

Definition at line 12854 of file pg_dump.c.

{
    char       *name;
    char       *paren;
    bool        inquote;
 
    /* In all cases "-" means a null reference */
    if (strcmp(proc, "-") == 0)
        return NULL;
 
    name = pg_strdup(proc);
    /* find non-double-quoted left paren */
    inquote = false;
    for (paren = name; *paren; paren++)
    {
        if (*paren == '(' && !inquote)
        {
            *paren = '\0';
            break;
        }
        if (*paren == '"')
            inquote = !inquote;
    }
    return name;
}

References name, and pg_strdup().

Referenced by dumpOpr().

convertTSFunction()

static char * convertTSFunction ( Archive *  fout, Oid  funcOid  )

static

Definition at line 12925 of file pg_dump.c.

{
    char       *result;
    char        query[128];
    PGresult   *res;
 
    snprintf(query, sizeof(query),
             "SELECT '%u'::pg_catalog.regproc", funcOid);
    res = ExecuteSqlQueryForSingleRow(fout, query);
 
    result = pg_strdup(PQgetvalue(res, 0, 0));
 
    PQclear(res);
 
    return result;
}

References ExecuteSqlQueryForSingleRow(), pg_strdup(), PQclear(), PQgetvalue(), res, and snprintf.

Referenced by dumpTSParser(), and dumpTSTemplate().

createBoundaryObjects()

static DumpableObject * createBoundaryObjects ( void  )

static

Definition at line 18405 of file pg_dump.c.

{
    DumpableObject *dobjs;
 
    dobjs = (DumpableObject *) pg_malloc(2 * sizeof(DumpableObject));
 
    dobjs[0].objType = DO_PRE_DATA_BOUNDARY;
    dobjs[0].catId = nilCatalogId;
    AssignDumpId(dobjs + 0);
    dobjs[0].name = pg_strdup("PRE-DATA BOUNDARY");
 
    dobjs[1].objType = DO_POST_DATA_BOUNDARY;
    dobjs[1].catId = nilCatalogId;
    AssignDumpId(dobjs + 1);
    dobjs[1].name = pg_strdup("POST-DATA BOUNDARY");
 
    return dobjs;
}

References AssignDumpId(), _dumpableObject::catId, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, _dumpableObject::name, nilCatalogId, _dumpableObject::objType, pg_malloc(), and pg_strdup().

Referenced by main().

createDummyViewAsClause()

static PQExpBuffer createDummyViewAsClause ( Archive *  fout, const TableInfo *  tbinfo  )

static

Definition at line 15561 of file pg_dump.c.

{
    PQExpBuffer result = createPQExpBuffer();
    int         j;
 
    appendPQExpBufferStr(result, "SELECT");
 
    for (j = 0; j < tbinfo->numatts; j++)
    {
        if (j > 0)
            appendPQExpBufferChar(result, ',');
        appendPQExpBufferStr(result, "\n    ");
 
        appendPQExpBuffer(result, "NULL::%s", tbinfo->atttypnames[j]);
 
        /*
         * Must add collation if not default for the type, because CREATE OR
         * REPLACE VIEW won't change it
         */
        if (OidIsValid(tbinfo->attcollation[j]))
        {
            CollInfo   *coll;
 
            coll = findCollationByOid(tbinfo->attcollation[j]);
            if (coll)
                appendPQExpBuffer(result, " COLLATE %s",
                                  fmtQualifiedDumpable(coll));
        }
 
        appendPQExpBuffer(result, " AS %s", fmtId(tbinfo->attnames[j]));
    }
 
    return result;
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), _tableInfo::attcollation, _tableInfo::attnames, _tableInfo::atttypnames, createPQExpBuffer(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, j, _tableInfo::numatts, and OidIsValid.

Referenced by dumpRule(), and dumpTableSchema().

createViewAsClause()

static PQExpBuffer createViewAsClause ( Archive *  fout, const TableInfo *  tbinfo  )

static

Definition at line 15512 of file pg_dump.c.

{
    PQExpBuffer query = createPQExpBuffer();
    PQExpBuffer result = createPQExpBuffer();
    PGresult   *res;
    int         len;
 
    /* Fetch the view definition */
    appendPQExpBuffer(query,
                      "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
                      tbinfo->dobj.catId.oid);
 
    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
 
    if (PQntuples(res) != 1)
    {
        if (PQntuples(res) < 1)
            pg_fatal("query to obtain definition of view \"%s\" returned no data",
                     tbinfo->dobj.name);
        else
            pg_fatal("query to obtain definition of view \"%s\" returned more than one definition",
                     tbinfo->dobj.name);
    }
 
    len = PQgetlength(res, 0, 0);
 
    if (len == 0)
        pg_fatal("definition of view \"%s\" appears to be empty (length zero)",
                 tbinfo->dobj.name);
 
    /* Strip off the trailing semicolon so that other things may follow. */
    Assert(PQgetvalue(res, 0, 0)[len - 1] == ';');
    appendBinaryPQExpBuffer(result, PQgetvalue(res, 0, 0), len - 1);
 
    PQclear(res);
    destroyPQExpBuffer(query);
 
    return result;
}

References appendBinaryPQExpBuffer(), appendPQExpBuffer(), Assert(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, ExecuteSqlQuery(), len, _dumpableObject::name, CatalogId::oid, pg_fatal, PGRES_TUPLES_OK, PQclear(), PQgetlength(), PQgetvalue(), PQntuples(), and res.

Referenced by dumpRule(), and dumpTableSchema().

dumpAccessMethod()

static void dumpAccessMethod ( Archive *  fout, const AccessMethodInfo *  aminfo  )

static

Definition at line 12947 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer q;
    PQExpBuffer delq;
    char       *qamname;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
 
    qamname = pg_strdup(fmtId(aminfo->dobj.name));
 
    appendPQExpBuffer(q, "CREATE ACCESS METHOD %s ", qamname);
 
    switch (aminfo->amtype)
    {
        case AMTYPE_INDEX:
            appendPQExpBufferStr(q, "TYPE INDEX ");
            break;
        case AMTYPE_TABLE:
            appendPQExpBufferStr(q, "TYPE TABLE ");
            break;
        default:
            pg_log_warning("invalid type \"%c\" of access method \"%s\"",
                           aminfo->amtype, qamname);
            destroyPQExpBuffer(q);
            destroyPQExpBuffer(delq);
            free(qamname);
            return;
    }
 
    appendPQExpBuffer(q, "HANDLER %s;\n", aminfo->amhandler);
 
    appendPQExpBuffer(delq, "DROP ACCESS METHOD %s;\n",
                      qamname);
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(q, &aminfo->dobj,
                                        "ACCESS METHOD", qamname, NULL);
 
    if (aminfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, aminfo->dobj.catId, aminfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = aminfo->dobj.name,
                                  .description = "ACCESS METHOD",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
    /* Dump Access Method Comments */
    if (aminfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "ACCESS METHOD", qamname,
                    NULL, "",
                    aminfo->dobj.catId, 0, aminfo->dobj.dumpId);
 
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    free(qamname);
}

References _accessMethodInfo::amhandler, _accessMethodInfo::amtype, appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), _accessMethodInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpableObject::dumpId, fmtId(), free, _dumpableObject::name, pg_log_warning, pg_strdup(), and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

dumpACL()

static DumpId dumpACL ( Archive *  fout, DumpId  objDumpId, DumpId  altDumpId, const char *  type, const char *  name, const char *  subname, const char *  nspname, const char *  owner, const DumpableAcl *  dacl  )

static

Definition at line 14919 of file pg_dump.c.

{
    DumpId      aclDumpId = InvalidDumpId;
    DumpOptions *dopt = fout->dopt;
    const char *acls = dacl->acl;
    const char *acldefault = dacl->acldefault;
    char        privtype = dacl->privtype;
    const char *initprivs = dacl->initprivs;
    const char *baseacls;
    PQExpBuffer sql;
 
    /* Do nothing if ACL dump is not enabled */
    if (dopt->aclsSkip)
        return InvalidDumpId;
 
    /* --data-only skips ACLs *except* large object ACLs */
    if (dopt->dataOnly && strcmp(type, "LARGE OBJECT") != 0)
        return InvalidDumpId;
 
    sql = createPQExpBuffer();
 
    /*
     * In binary upgrade mode, we don't run an extension's script but instead
     * dump out the objects independently and then recreate them.  To preserve
     * any initial privileges which were set on extension objects, we need to
     * compute the set of GRANT and REVOKE commands necessary to get from the
     * default privileges of an object to its initial privileges as recorded
     * in pg_init_privs.
     *
     * At restore time, we apply these commands after having called
     * binary_upgrade_set_record_init_privs(true).  That tells the backend to
     * copy the results into pg_init_privs.  This is how we preserve the
     * contents of that catalog across binary upgrades.
     */
    if (dopt->binary_upgrade && privtype == 'e' &&
        initprivs && *initprivs != '\0')
    {
        appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(true);\n");
        if (!buildACLCommands(name, subname, nspname, type,
                              initprivs, acldefault, owner,
                              "", fout->remoteVersion, sql))
            pg_fatal("could not parse initial ACL list (%s) or default (%s) for object \"%s\" (%s)",
                     initprivs, acldefault, name, type);
        appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
    }
 
    /*
     * Now figure the GRANT and REVOKE commands needed to get to the object's
     * actual current ACL, starting from the initprivs if given, else from the
     * object-type-specific default.  Also, while buildACLCommands will assume
     * that a NULL/empty acls string means it needn't do anything, what that
     * actually represents is the object-type-specific default; so we need to
     * substitute the acldefault string to get the right results in that case.
     */
    if (initprivs && *initprivs != '\0')
    {
        baseacls = initprivs;
        if (acls == NULL || *acls == '\0')
            acls = acldefault;
    }
    else
        baseacls = acldefault;
 
    if (!buildACLCommands(name, subname, nspname, type,
                          acls, baseacls, owner,
                          "", fout->remoteVersion, sql))
        pg_fatal("could not parse ACL list (%s) or default (%s) for object \"%s\" (%s)",
                 acls, baseacls, name, type);
 
    if (sql->len > 0)
    {
        PQExpBuffer tag = createPQExpBuffer();
        DumpId      aclDeps[2];
        int         nDeps = 0;
 
        if (subname)
            appendPQExpBuffer(tag, "COLUMN %s.%s", name, subname);
        else
            appendPQExpBuffer(tag, "%s %s", type, name);
 
        aclDeps[nDeps++] = objDumpId;
        if (altDumpId != InvalidDumpId)
            aclDeps[nDeps++] = altDumpId;
 
        aclDumpId = createDumpId();
 
        ArchiveEntry(fout, nilCatalogId, aclDumpId,
                     ARCHIVE_OPTS(.tag = tag->data,
                                  .namespace = nspname,
                                  .owner = owner,
                                  .description = "ACL",
                                  .section = SECTION_NONE,
                                  .createStmt = sql->data,
                                  .deps = aclDeps,
                                  .nDeps = nDeps));
 
        destroyPQExpBuffer(tag);
    }
 
    destroyPQExpBuffer(sql);
 
    return aclDumpId;
}

References _dumpableAcl::acl, acldefault(), _dumpableAcl::acldefault, _dumpOptions::aclsSkip, appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, buildACLCommands(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), Archive::dopt, _dumpableAcl::initprivs, InvalidDumpId, PQExpBufferData::len, name, nilCatalogId, pg_fatal, _dumpableAcl::privtype, Archive::remoteVersion, SECTION_NONE, subname, and type.

Referenced by dumpAgg(), dumpBaseType(), dumpCompositeType(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpLO(), dumpNamespace(), dumpProcLang(), dumpRangeType(), dumpTable(), and dumpUndefinedType().

dumpAgg()

static void dumpAgg ( Archive *  fout, const AggInfo *  agginfo  )

static

Definition at line 13886 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer details;
    char       *aggsig;         /* identity signature */
    char       *aggfullsig = NULL;  /* full signature */
    char       *aggsig_tag;
    PGresult   *res;
    int         i_agginitval;
    int         i_aggminitval;
    const char *aggtransfn;
    const char *aggfinalfn;
    const char *aggcombinefn;
    const char *aggserialfn;
    const char *aggdeserialfn;
    const char *aggmtransfn;
    const char *aggminvtransfn;
    const char *aggmfinalfn;
    bool        aggfinalextra;
    bool        aggmfinalextra;
    char        aggfinalmodify;
    char        aggmfinalmodify;
    const char *aggsortop;
    char       *aggsortconvop;
    char        aggkind;
    const char *aggtranstype;
    const char *aggtransspace;
    const char *aggmtranstype;
    const char *aggmtransspace;
    const char *agginitval;
    const char *aggminitval;
    const char *proparallel;
    char        defaultfinalmodify;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    details = createPQExpBuffer();
 
    if (!fout->is_prepared[PREPQUERY_DUMPAGG])
    {
        /* Set up query for aggregate-specific details */
        appendPQExpBufferStr(query,
                             "PREPARE dumpAgg(pg_catalog.oid) AS\n");
 
        appendPQExpBufferStr(query,
                             "SELECT "
                             "aggtransfn,\n"
                             "aggfinalfn,\n"
                             "aggtranstype::pg_catalog.regtype,\n"
                             "agginitval,\n"
                             "aggsortop,\n"
                             "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
                             "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
 
        if (fout->remoteVersion >= 90400)
            appendPQExpBufferStr(query,
                                 "aggkind,\n"
                                 "aggmtransfn,\n"
                                 "aggminvtransfn,\n"
                                 "aggmfinalfn,\n"
                                 "aggmtranstype::pg_catalog.regtype,\n"
                                 "aggfinalextra,\n"
                                 "aggmfinalextra,\n"
                                 "aggtransspace,\n"
                                 "aggmtransspace,\n"
                                 "aggminitval,\n");
        else
            appendPQExpBufferStr(query,
                                 "'n' AS aggkind,\n"
                                 "'-' AS aggmtransfn,\n"
                                 "'-' AS aggminvtransfn,\n"
                                 "'-' AS aggmfinalfn,\n"
                                 "0 AS aggmtranstype,\n"
                                 "false AS aggfinalextra,\n"
                                 "false AS aggmfinalextra,\n"
                                 "0 AS aggtransspace,\n"
                                 "0 AS aggmtransspace,\n"
                                 "NULL AS aggminitval,\n");
 
        if (fout->remoteVersion >= 90600)
            appendPQExpBufferStr(query,
                                 "aggcombinefn,\n"
                                 "aggserialfn,\n"
                                 "aggdeserialfn,\n"
                                 "proparallel,\n");
        else
            appendPQExpBufferStr(query,
                                 "'-' AS aggcombinefn,\n"
                                 "'-' AS aggserialfn,\n"
                                 "'-' AS aggdeserialfn,\n"
                                 "'u' AS proparallel,\n");
 
        if (fout->remoteVersion >= 110000)
            appendPQExpBufferStr(query,
                                 "aggfinalmodify,\n"
                                 "aggmfinalmodify\n");
        else
            appendPQExpBufferStr(query,
                                 "'0' AS aggfinalmodify,\n"
                                 "'0' AS aggmfinalmodify\n");
 
        appendPQExpBufferStr(query,
                             "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
                             "WHERE a.aggfnoid = p.oid "
                             "AND p.oid = $1");
 
        ExecuteSqlStatement(fout, query->data);
 
        fout->is_prepared[PREPQUERY_DUMPAGG] = true;
    }
 
    printfPQExpBuffer(query,
                      "EXECUTE dumpAgg('%u')",
                      agginfo->aggfn.dobj.catId.oid);
 
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
 
    i_agginitval = PQfnumber(res, "agginitval");
    i_aggminitval = PQfnumber(res, "aggminitval");
 
    aggtransfn = PQgetvalue(res, 0, PQfnumber(res, "aggtransfn"));
    aggfinalfn = PQgetvalue(res, 0, PQfnumber(res, "aggfinalfn"));
    aggcombinefn = PQgetvalue(res, 0, PQfnumber(res, "aggcombinefn"));
    aggserialfn = PQgetvalue(res, 0, PQfnumber(res, "aggserialfn"));
    aggdeserialfn = PQgetvalue(res, 0, PQfnumber(res, "aggdeserialfn"));
    aggmtransfn = PQgetvalue(res, 0, PQfnumber(res, "aggmtransfn"));
    aggminvtransfn = PQgetvalue(res, 0, PQfnumber(res, "aggminvtransfn"));
    aggmfinalfn = PQgetvalue(res, 0, PQfnumber(res, "aggmfinalfn"));
    aggfinalextra = (PQgetvalue(res, 0, PQfnumber(res, "aggfinalextra"))[0] == 't');
    aggmfinalextra = (PQgetvalue(res, 0, PQfnumber(res, "aggmfinalextra"))[0] == 't');
    aggfinalmodify = PQgetvalue(res, 0, PQfnumber(res, "aggfinalmodify"))[0];
    aggmfinalmodify = PQgetvalue(res, 0, PQfnumber(res, "aggmfinalmodify"))[0];
    aggsortop = PQgetvalue(res, 0, PQfnumber(res, "aggsortop"));
    aggkind = PQgetvalue(res, 0, PQfnumber(res, "aggkind"))[0];
    aggtranstype = PQgetvalue(res, 0, PQfnumber(res, "aggtranstype"));
    aggtransspace = PQgetvalue(res, 0, PQfnumber(res, "aggtransspace"));
    aggmtranstype = PQgetvalue(res, 0, PQfnumber(res, "aggmtranstype"));
    aggmtransspace = PQgetvalue(res, 0, PQfnumber(res, "aggmtransspace"));
    agginitval = PQgetvalue(res, 0, i_agginitval);
    aggminitval = PQgetvalue(res, 0, i_aggminitval);
    proparallel = PQgetvalue(res, 0, PQfnumber(res, "proparallel"));
 
    {
        char       *funcargs;
        char       *funciargs;
 
        funcargs = PQgetvalue(res, 0, PQfnumber(res, "funcargs"));
        funciargs = PQgetvalue(res, 0, PQfnumber(res, "funciargs"));
        aggfullsig = format_function_arguments(&agginfo->aggfn, funcargs, true);
        aggsig = format_function_arguments(&agginfo->aggfn, funciargs, true);
    }
 
    aggsig_tag = format_aggregate_signature(agginfo, fout, false);
 
    /* identify default modify flag for aggkind (must match DefineAggregate) */
    defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
    /* replace omitted flags for old versions */
    if (aggfinalmodify == '0')
        aggfinalmodify = defaultfinalmodify;
    if (aggmfinalmodify == '0')
        aggmfinalmodify = defaultfinalmodify;
 
    /* regproc and regtype output is already sufficiently quoted */
    appendPQExpBuffer(details, "    SFUNC = %s,\n    STYPE = %s",
                      aggtransfn, aggtranstype);
 
    if (strcmp(aggtransspace, "0") != 0)
    {
        appendPQExpBuffer(details, ",\n    SSPACE = %s",
                          aggtransspace);
    }
 
    if (!PQgetisnull(res, 0, i_agginitval))
    {
        appendPQExpBufferStr(details, ",\n    INITCOND = ");
        appendStringLiteralAH(details, agginitval, fout);
    }
 
    if (strcmp(aggfinalfn, "-") != 0)
    {
        appendPQExpBuffer(details, ",\n    FINALFUNC = %s",
                          aggfinalfn);
        if (aggfinalextra)
            appendPQExpBufferStr(details, ",\n    FINALFUNC_EXTRA");
        if (aggfinalmodify != defaultfinalmodify)
        {
            switch (aggfinalmodify)
            {
                case AGGMODIFY_READ_ONLY:
                    appendPQExpBufferStr(details, ",\n    FINALFUNC_MODIFY = READ_ONLY");
                    break;
                case AGGMODIFY_SHAREABLE:
                    appendPQExpBufferStr(details, ",\n    FINALFUNC_MODIFY = SHAREABLE");
                    break;
                case AGGMODIFY_READ_WRITE:
                    appendPQExpBufferStr(details, ",\n    FINALFUNC_MODIFY = READ_WRITE");
                    break;
                default:
                    pg_fatal("unrecognized aggfinalmodify value for aggregate \"%s\"",
                             agginfo->aggfn.dobj.name);
                    break;
            }
        }
    }
 
    if (strcmp(aggcombinefn, "-") != 0)
        appendPQExpBuffer(details, ",\n    COMBINEFUNC = %s", aggcombinefn);
 
    if (strcmp(aggserialfn, "-") != 0)
        appendPQExpBuffer(details, ",\n    SERIALFUNC = %s", aggserialfn);
 
    if (strcmp(aggdeserialfn, "-") != 0)
        appendPQExpBuffer(details, ",\n    DESERIALFUNC = %s", aggdeserialfn);
 
    if (strcmp(aggmtransfn, "-") != 0)
    {
        appendPQExpBuffer(details, ",\n    MSFUNC = %s,\n    MINVFUNC = %s,\n    MSTYPE = %s",
                          aggmtransfn,
                          aggminvtransfn,
                          aggmtranstype);
    }
 
    if (strcmp(aggmtransspace, "0") != 0)
    {
        appendPQExpBuffer(details, ",\n    MSSPACE = %s",
                          aggmtransspace);
    }
 
    if (!PQgetisnull(res, 0, i_aggminitval))
    {
        appendPQExpBufferStr(details, ",\n    MINITCOND = ");
        appendStringLiteralAH(details, aggminitval, fout);
    }
 
    if (strcmp(aggmfinalfn, "-") != 0)
    {
        appendPQExpBuffer(details, ",\n    MFINALFUNC = %s",
                          aggmfinalfn);
        if (aggmfinalextra)
            appendPQExpBufferStr(details, ",\n    MFINALFUNC_EXTRA");
        if (aggmfinalmodify != defaultfinalmodify)
        {
            switch (aggmfinalmodify)
            {
                case AGGMODIFY_READ_ONLY:
                    appendPQExpBufferStr(details, ",\n    MFINALFUNC_MODIFY = READ_ONLY");
                    break;
                case AGGMODIFY_SHAREABLE:
                    appendPQExpBufferStr(details, ",\n    MFINALFUNC_MODIFY = SHAREABLE");
                    break;
                case AGGMODIFY_READ_WRITE:
                    appendPQExpBufferStr(details, ",\n    MFINALFUNC_MODIFY = READ_WRITE");
                    break;
                default:
                    pg_fatal("unrecognized aggmfinalmodify value for aggregate \"%s\"",
                             agginfo->aggfn.dobj.name);
                    break;
            }
        }
    }
 
    aggsortconvop = getFormattedOperatorName(aggsortop);
    if (aggsortconvop)
    {
        appendPQExpBuffer(details, ",\n    SORTOP = %s",
                          aggsortconvop);
        free(aggsortconvop);
    }
 
    if (aggkind == AGGKIND_HYPOTHETICAL)
        appendPQExpBufferStr(details, ",\n    HYPOTHETICAL");
 
    if (proparallel[0] != PROPARALLEL_UNSAFE)
    {
        if (proparallel[0] == PROPARALLEL_SAFE)
            appendPQExpBufferStr(details, ",\n    PARALLEL = safe");
        else if (proparallel[0] == PROPARALLEL_RESTRICTED)
            appendPQExpBufferStr(details, ",\n    PARALLEL = restricted");
        else if (proparallel[0] != PROPARALLEL_UNSAFE)
            pg_fatal("unrecognized proparallel value for function \"%s\"",
                     agginfo->aggfn.dobj.name);
    }
 
    appendPQExpBuffer(delq, "DROP AGGREGATE %s.%s;\n",
                      fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
                      aggsig);
 
    appendPQExpBuffer(q, "CREATE AGGREGATE %s.%s (\n%s\n);\n",
                      fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
                      aggfullsig ? aggfullsig : aggsig, details->data);
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(q, &agginfo->aggfn.dobj,
                                        "AGGREGATE", aggsig,
                                        agginfo->aggfn.dobj.namespace->dobj.name);
 
    if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, agginfo->aggfn.dobj.catId,
                     agginfo->aggfn.dobj.dumpId,
                     ARCHIVE_OPTS(.tag = aggsig_tag,
                                  .namespace = agginfo->aggfn.dobj.namespace->dobj.name,
                                  .owner = agginfo->aggfn.rolname,
                                  .description = "AGGREGATE",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
    /* Dump Aggregate Comments */
    if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "AGGREGATE", aggsig,
                    agginfo->aggfn.dobj.namespace->dobj.name,
                    agginfo->aggfn.rolname,
                    agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
 
    if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_SECLABEL)
        dumpSecLabel(fout, "AGGREGATE", aggsig,
                     agginfo->aggfn.dobj.namespace->dobj.name,
                     agginfo->aggfn.rolname,
                     agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
 
    /*
     * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
     * command look like a function's GRANT; in particular this affects the
     * syntax for zero-argument aggregates and ordered-set aggregates.
     */
    free(aggsig);
 
    aggsig = format_function_signature(fout, &agginfo->aggfn, true);
 
    if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_ACL)
        dumpACL(fout, agginfo->aggfn.dobj.dumpId, InvalidDumpId,
                "FUNCTION", aggsig, NULL,
                agginfo->aggfn.dobj.namespace->dobj.name,
                agginfo->aggfn.rolname, &agginfo->aggfn.dacl);
 
    free(aggsig);
    free(aggfullsig);
    free(aggsig_tag);
 
    PQclear(res);
 
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(details);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), Archive::dopt, DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fmtId(), format_aggregate_signature(), format_function_arguments(), format_function_signature(), free, getFormattedOperatorName(), InvalidDumpId, Archive::is_prepared, pg_fatal, PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), PREPQUERY_DUMPAGG, printfPQExpBuffer(), Archive::remoteVersion, res, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

dumpAttrDef()

static void dumpAttrDef ( Archive *  fout, const AttrDefInfo *  adinfo  )

static

Definition at line 16507 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    TableInfo  *tbinfo = adinfo->adtable;
    int         adnum = adinfo->adnum;
    PQExpBuffer q;
    PQExpBuffer delq;
    char       *qualrelname;
    char       *tag;
    char       *foreign;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    /* Skip if not "separate"; it was dumped in the table's definition */
    if (!adinfo->separate)
        return;
 
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
 
    qualrelname = pg_strdup(fmtQualifiedDumpable(tbinfo));
 
    foreign = tbinfo->relkind == RELKIND_FOREIGN_TABLE ? "FOREIGN " : "";
 
    appendPQExpBuffer(q,
                      "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
                      foreign, qualrelname, fmtId(tbinfo->attnames[adnum - 1]),
                      adinfo->adef_expr);
 
    appendPQExpBuffer(delq, "ALTER %sTABLE %s ALTER COLUMN %s DROP DEFAULT;\n",
                      foreign, qualrelname,
                      fmtId(tbinfo->attnames[adnum - 1]));
 
    tag = psprintf("%s %s", tbinfo->dobj.name, tbinfo->attnames[adnum - 1]);
 
    if (adinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, adinfo->dobj.catId, adinfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = tag,
                                  .namespace = tbinfo->dobj.namespace->dobj.name,
                                  .owner = tbinfo->rolname,
                                  .description = "DEFAULT",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
    free(tag);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    free(qualrelname);
}

References _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, appendPQExpBuffer(), ARCHIVE_OPTS, ArchiveEntry(), _tableInfo::attnames, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _attrDefInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_DEFINITION, _dumpableObject::dumpId, fmtId(), fmtQualifiedDumpable, free, _dumpableObject::name, pg_strdup(), psprintf(), _tableInfo::relkind, _tableInfo::rolname, SECTION_PRE_DATA, and _attrDefInfo::separate.

Referenced by dumpDumpableObject().

dumpBaseType()

static void dumpBaseType ( Archive *  fout, const TypeInfo *  tyinfo  )

static

Definition at line 11038 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    char       *qtypname;
    char       *qualtypname;
    char       *typlen;
    char       *typinput;
    char       *typoutput;
    char       *typreceive;
    char       *typsend;
    char       *typmodin;
    char       *typmodout;
    char       *typanalyze;
    char       *typsubscript;
    Oid         typreceiveoid;
    Oid         typsendoid;
    Oid         typmodinoid;
    Oid         typmodoutoid;
    Oid         typanalyzeoid;
    Oid         typsubscriptoid;
    char       *typcategory;
    char       *typispreferred;
    char       *typdelim;
    char       *typbyval;
    char       *typalign;
    char       *typstorage;
    char       *typcollatable;
    char       *typdefault;
    bool        typdefault_is_literal = false;
 
    if (!fout->is_prepared[PREPQUERY_DUMPBASETYPE])
    {
        /* Set up query for type-specific details */
        appendPQExpBufferStr(query,
                             "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
                             "SELECT typlen, "
                             "typinput, typoutput, typreceive, typsend, "
                             "typreceive::pg_catalog.oid AS typreceiveoid, "
                             "typsend::pg_catalog.oid AS typsendoid, "
                             "typanalyze, "
                             "typanalyze::pg_catalog.oid AS typanalyzeoid, "
                             "typdelim, typbyval, typalign, typstorage, "
                             "typmodin, typmodout, "
                             "typmodin::pg_catalog.oid AS typmodinoid, "
                             "typmodout::pg_catalog.oid AS typmodoutoid, "
                             "typcategory, typispreferred, "
                             "(typcollation <> 0) AS typcollatable, "
                             "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
 
        if (fout->remoteVersion >= 140000)
            appendPQExpBufferStr(query,
                                 "typsubscript, "
                                 "typsubscript::pg_catalog.oid AS typsubscriptoid ");
        else
            appendPQExpBufferStr(query,
                                 "'-' AS typsubscript, 0 AS typsubscriptoid ");
 
        appendPQExpBufferStr(query, "FROM pg_catalog.pg_type "
                             "WHERE oid = $1");
 
        ExecuteSqlStatement(fout, query->data);
 
        fout->is_prepared[PREPQUERY_DUMPBASETYPE] = true;
    }
 
    printfPQExpBuffer(query,
                      "EXECUTE dumpBaseType('%u')",
                      tyinfo->dobj.catId.oid);
 
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
 
    typlen = PQgetvalue(res, 0, PQfnumber(res, "typlen"));
    typinput = PQgetvalue(res, 0, PQfnumber(res, "typinput"));
    typoutput = PQgetvalue(res, 0, PQfnumber(res, "typoutput"));
    typreceive = PQgetvalue(res, 0, PQfnumber(res, "typreceive"));
    typsend = PQgetvalue(res, 0, PQfnumber(res, "typsend"));
    typmodin = PQgetvalue(res, 0, PQfnumber(res, "typmodin"));
    typmodout = PQgetvalue(res, 0, PQfnumber(res, "typmodout"));
    typanalyze = PQgetvalue(res, 0, PQfnumber(res, "typanalyze"));
    typsubscript = PQgetvalue(res, 0, PQfnumber(res, "typsubscript"));
    typreceiveoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typreceiveoid")));
    typsendoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typsendoid")));
    typmodinoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typmodinoid")));
    typmodoutoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typmodoutoid")));
    typanalyzeoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typanalyzeoid")));
    typsubscriptoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typsubscriptoid")));
    typcategory = PQgetvalue(res, 0, PQfnumber(res, "typcategory"));
    typispreferred = PQgetvalue(res, 0, PQfnumber(res, "typispreferred"));
    typdelim = PQgetvalue(res, 0, PQfnumber(res, "typdelim"));
    typbyval = PQgetvalue(res, 0, PQfnumber(res, "typbyval"));
    typalign = PQgetvalue(res, 0, PQfnumber(res, "typalign"));
    typstorage = PQgetvalue(res, 0, PQfnumber(res, "typstorage"));
    typcollatable = PQgetvalue(res, 0, PQfnumber(res, "typcollatable"));
    if (!PQgetisnull(res, 0, PQfnumber(res, "typdefaultbin")))
        typdefault = PQgetvalue(res, 0, PQfnumber(res, "typdefaultbin"));
    else if (!PQgetisnull(res, 0, PQfnumber(res, "typdefault")))
    {
        typdefault = PQgetvalue(res, 0, PQfnumber(res, "typdefault"));
        typdefault_is_literal = true;   /* it needs quotes */
    }
    else
        typdefault = NULL;
 
    qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
    qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
 
    /*
     * The reason we include CASCADE is that the circular dependency between
     * the type and its I/O functions makes it impossible to drop the type any
     * other way.
     */
    appendPQExpBuffer(delq, "DROP TYPE %s CASCADE;\n", qualtypname);
 
    /*
     * We might already have a shell type, but setting pg_type_oid is
     * harmless, and in any case we'd better set the array type OID.
     */
    if (dopt->binary_upgrade)
        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                                 tyinfo->dobj.catId.oid,
                                                 false, false);
 
    appendPQExpBuffer(q,
                      "CREATE TYPE %s (\n"
                      "    INTERNALLENGTH = %s",
                      qualtypname,
                      (strcmp(typlen, "-1") == 0) ? "variable" : typlen);
 
    /* regproc result is sufficiently quoted already */
    appendPQExpBuffer(q, ",\n    INPUT = %s", typinput);
    appendPQExpBuffer(q, ",\n    OUTPUT = %s", typoutput);
    if (OidIsValid(typreceiveoid))
        appendPQExpBuffer(q, ",\n    RECEIVE = %s", typreceive);
    if (OidIsValid(typsendoid))
        appendPQExpBuffer(q, ",\n    SEND = %s", typsend);
    if (OidIsValid(typmodinoid))
        appendPQExpBuffer(q, ",\n    TYPMOD_IN = %s", typmodin);
    if (OidIsValid(typmodoutoid))
        appendPQExpBuffer(q, ",\n    TYPMOD_OUT = %s", typmodout);
    if (OidIsValid(typanalyzeoid))
        appendPQExpBuffer(q, ",\n    ANALYZE = %s", typanalyze);
 
    if (strcmp(typcollatable, "t") == 0)
        appendPQExpBufferStr(q, ",\n    COLLATABLE = true");
 
    if (typdefault != NULL)
    {
        appendPQExpBufferStr(q, ",\n    DEFAULT = ");
        if (typdefault_is_literal)
            appendStringLiteralAH(q, typdefault, fout);
        else
            appendPQExpBufferStr(q, typdefault);
    }
 
    if (OidIsValid(typsubscriptoid))
        appendPQExpBuffer(q, ",\n    SUBSCRIPT = %s", typsubscript);
 
    if (OidIsValid(tyinfo->typelem))
        appendPQExpBuffer(q, ",\n    ELEMENT = %s",
                          getFormattedTypeName(fout, tyinfo->typelem,
                                               zeroIsError));
 
    if (strcmp(typcategory, "U") != 0)
    {
        appendPQExpBufferStr(q, ",\n    CATEGORY = ");
        appendStringLiteralAH(q, typcategory, fout);
    }
 
    if (strcmp(typispreferred, "t") == 0)
        appendPQExpBufferStr(q, ",\n    PREFERRED = true");
 
    if (typdelim && strcmp(typdelim, ",") != 0)
    {
        appendPQExpBufferStr(q, ",\n    DELIMITER = ");
        appendStringLiteralAH(q, typdelim, fout);
    }
 
    if (*typalign == TYPALIGN_CHAR)
        appendPQExpBufferStr(q, ",\n    ALIGNMENT = char");
    else if (*typalign == TYPALIGN_SHORT)
        appendPQExpBufferStr(q, ",\n    ALIGNMENT = int2");
    else if (*typalign == TYPALIGN_INT)
        appendPQExpBufferStr(q, ",\n    ALIGNMENT = int4");
    else if (*typalign == TYPALIGN_DOUBLE)
        appendPQExpBufferStr(q, ",\n    ALIGNMENT = double");
 
    if (*typstorage == TYPSTORAGE_PLAIN)
        appendPQExpBufferStr(q, ",\n    STORAGE = plain");
    else if (*typstorage == TYPSTORAGE_EXTERNAL)
        appendPQExpBufferStr(q, ",\n    STORAGE = external");
    else if (*typstorage == TYPSTORAGE_EXTENDED)
        appendPQExpBufferStr(q, ",\n    STORAGE = extended");
    else if (*typstorage == TYPSTORAGE_MAIN)
        appendPQExpBufferStr(q, ",\n    STORAGE = main");
 
    if (strcmp(typbyval, "t") == 0)
        appendPQExpBufferStr(q, ",\n    PASSEDBYVALUE");
 
    appendPQExpBufferStr(q, "\n);\n");
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj,
                                        "TYPE", qtypname,
                                        tyinfo->dobj.namespace->dobj.name);
 
    if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
                                  .namespace = tyinfo->dobj.namespace->dobj.name,
                                  .owner = tyinfo->rolname,
                                  .description = "TYPE",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
    /* Dump Type Comments and Security Labels */
    if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "TYPE", qtypname,
                    tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                    tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
 
    if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
        dumpSecLabel(fout, "TYPE", qtypname,
                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
 
    if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
        dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
                qtypname, NULL,
                tyinfo->dobj.namespace->dobj.name,
                tyinfo->rolname, &tyinfo->dacl);
 
    PQclear(res);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(query);
    free(qtypname);
    free(qualtypname);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), _dumpableObject::catId, createPQExpBuffer(), _typeInfo::dacl, PQExpBufferData::data, destroyPQExpBuffer(), _typeInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), ExecuteSqlQueryForSingleRow(), ExecuteSqlStatement(), fmtId(), fmtQualifiedDumpable, free, getFormattedTypeName(), InvalidDumpId, Archive::is_prepared, _dumpableObject::name, CatalogId::oid, OidIsValid, pg_strdup(), PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), PREPQUERY_DUMPBASETYPE, printfPQExpBuffer(), Archive::remoteVersion, res, _typeInfo::rolname, SECTION_PRE_DATA, typalign, _typeInfo::typelem, and zeroIsError.

Referenced by dumpType().

dumpCast()

static void dumpCast ( Archive *  fout, const CastInfo *  cast  )

static

Definition at line 12401 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer defqry;
    PQExpBuffer delqry;
    PQExpBuffer labelq;
    PQExpBuffer castargs;
    FuncInfo   *funcInfo = NULL;
    const char *sourceType;
    const char *targetType;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    /* Cannot dump if we don't have the cast function's info */
    if (OidIsValid(cast->castfunc))
    {
        funcInfo = findFuncByOid(cast->castfunc);
        if (funcInfo == NULL)
            pg_fatal("could not find function definition for function with OID %u",
                     cast->castfunc);
    }
 
    defqry = createPQExpBuffer();
    delqry = createPQExpBuffer();
    labelq = createPQExpBuffer();
    castargs = createPQExpBuffer();
 
    sourceType = getFormattedTypeName(fout, cast->castsource, zeroAsNone);
    targetType = getFormattedTypeName(fout, cast->casttarget, zeroAsNone);
    appendPQExpBuffer(delqry, "DROP CAST (%s AS %s);\n",
                      sourceType, targetType);
 
    appendPQExpBuffer(defqry, "CREATE CAST (%s AS %s) ",
                      sourceType, targetType);
 
    switch (cast->castmethod)
    {
        case COERCION_METHOD_BINARY:
            appendPQExpBufferStr(defqry, "WITHOUT FUNCTION");
            break;
        case COERCION_METHOD_INOUT:
            appendPQExpBufferStr(defqry, "WITH INOUT");
            break;
        case COERCION_METHOD_FUNCTION:
            if (funcInfo)
            {
                char       *fsig = format_function_signature(fout, funcInfo, true);
 
                /*
                 * Always qualify the function name (format_function_signature
                 * won't qualify it).
                 */
                appendPQExpBuffer(defqry, "WITH FUNCTION %s.%s",
                                  fmtId(funcInfo->dobj.namespace->dobj.name), fsig);
                free(fsig);
            }
            else
                pg_log_warning("bogus value in pg_cast.castfunc or pg_cast.castmethod field");
            break;
        default:
            pg_log_warning("bogus value in pg_cast.castmethod field");
    }
 
    if (cast->castcontext == 'a')
        appendPQExpBufferStr(defqry, " AS ASSIGNMENT");
    else if (cast->castcontext == 'i')
        appendPQExpBufferStr(defqry, " AS IMPLICIT");
    appendPQExpBufferStr(defqry, ";\n");
 
    appendPQExpBuffer(labelq, "CAST (%s AS %s)",
                      sourceType, targetType);
 
    appendPQExpBuffer(castargs, "(%s AS %s)",
                      sourceType, targetType);
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(defqry, &cast->dobj,
                                        "CAST", castargs->data, NULL);
 
    if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = labelq->data,
                                  .description = "CAST",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = defqry->data,
                                  .dropStmt = delqry->data));
 
    /* Dump Cast Comments */
    if (cast->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "CAST", castargs->data,
                    NULL, "",
                    cast->dobj.catId, 0, cast->dobj.dumpId);
 
    destroyPQExpBuffer(defqry);
    destroyPQExpBuffer(delqry);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(castargs);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), _castInfo::castcontext, _castInfo::castfunc, _castInfo::castmethod, _castInfo::castsource, _castInfo::casttarget, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), _funcInfo::dobj, _castInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpableObject::dumpId, findFuncByOid(), fmtId(), format_function_signature(), free, getFormattedTypeName(), _dumpableObject::name, OidIsValid, pg_fatal, pg_log_warning, SECTION_PRE_DATA, and zeroAsNone.

Referenced by dumpDumpableObject().

dumpCollation()

static void dumpCollation ( Archive *  fout, const CollInfo *  collinfo  )

static

Definition at line 13515 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    char       *qcollname;
    PGresult   *res;
    int         i_collprovider;
    int         i_collisdeterministic;
    int         i_collcollate;
    int         i_collctype;
    int         i_colliculocale;
    int         i_collicurules;
    const char *collprovider;
    const char *collcollate;
    const char *collctype;
    const char *colliculocale;
    const char *collicurules;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
 
    qcollname = pg_strdup(fmtId(collinfo->dobj.name));
 
    /* Get collation-specific details */
    appendPQExpBufferStr(query, "SELECT ");
 
    if (fout->remoteVersion >= 100000)
        appendPQExpBufferStr(query,
                             "collprovider, "
                             "collversion, ");
    else
        appendPQExpBufferStr(query,
                             "'c' AS collprovider, "
                             "NULL AS collversion, ");
 
    if (fout->remoteVersion >= 120000)
        appendPQExpBufferStr(query,
                             "collisdeterministic, ");
    else
        appendPQExpBufferStr(query,
                             "true AS collisdeterministic, ");
 
    if (fout->remoteVersion >= 150000)
        appendPQExpBufferStr(query,
                             "colliculocale, ");
    else
        appendPQExpBufferStr(query,
                             "NULL AS colliculocale, ");
 
    if (fout->remoteVersion >= 160000)
        appendPQExpBufferStr(query,
                             "collicurules, ");
    else
        appendPQExpBufferStr(query,
                             "NULL AS collicurules, ");
 
    appendPQExpBuffer(query,
                      "collcollate, "
                      "collctype "
                      "FROM pg_catalog.pg_collation c "
                      "WHERE c.oid = '%u'::pg_catalog.oid",
                      collinfo->dobj.catId.oid);
 
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
 
    i_collprovider = PQfnumber(res, "collprovider");
    i_collisdeterministic = PQfnumber(res, "collisdeterministic");
    i_collcollate = PQfnumber(res, "collcollate");
    i_collctype = PQfnumber(res, "collctype");
    i_colliculocale = PQfnumber(res, "colliculocale");
    i_collicurules = PQfnumber(res, "collicurules");
 
    collprovider = PQgetvalue(res, 0, i_collprovider);
 
    if (!PQgetisnull(res, 0, i_collcollate))
        collcollate = PQgetvalue(res, 0, i_collcollate);
    else
        collcollate = NULL;
 
    if (!PQgetisnull(res, 0, i_collctype))
        collctype = PQgetvalue(res, 0, i_collctype);
    else
        collctype = NULL;
 
    /*
     * Before version 15, collcollate and collctype were of type NAME and
     * non-nullable. Treat empty strings as NULL for consistency.
     */
    if (fout->remoteVersion < 150000)
    {
        if (collcollate[0] == '\0')
            collcollate = NULL;
        if (collctype[0] == '\0')
            collctype = NULL;
    }
 
    if (!PQgetisnull(res, 0, i_colliculocale))
        colliculocale = PQgetvalue(res, 0, i_colliculocale);
    else
        colliculocale = NULL;
 
    if (!PQgetisnull(res, 0, i_collicurules))
        collicurules = PQgetvalue(res, 0, i_collicurules);
    else
        collicurules = NULL;
 
    appendPQExpBuffer(delq, "DROP COLLATION %s;\n",
                      fmtQualifiedDumpable(collinfo));
 
    appendPQExpBuffer(q, "CREATE COLLATION %s (",
                      fmtQualifiedDumpable(collinfo));
 
    appendPQExpBufferStr(q, "provider = ");
    if (collprovider[0] == 'c')
        appendPQExpBufferStr(q, "libc");
    else if (collprovider[0] == 'i')
        appendPQExpBufferStr(q, "icu");
    else if (collprovider[0] == 'd')
        /* to allow dumping pg_catalog; not accepted on input */
        appendPQExpBufferStr(q, "default");
    else
        pg_fatal("unrecognized collation provider: %s",
                 collprovider);
 
    if (strcmp(PQgetvalue(res, 0, i_collisdeterministic), "f") == 0)
        appendPQExpBufferStr(q, ", deterministic = false");
 
    if (collprovider[0] == 'd')
    {
        if (collcollate || collctype || colliculocale || collicurules)
            pg_log_warning("invalid collation \"%s\"", qcollname);
 
        /* no locale -- the default collation cannot be reloaded anyway */
    }
    else if (collprovider[0] == 'i')
    {
        if (fout->remoteVersion >= 150000)
        {
            if (collcollate || collctype || !colliculocale)
                pg_log_warning("invalid collation \"%s\"", qcollname);
 
            appendPQExpBufferStr(q, ", locale = ");
            appendStringLiteralAH(q, colliculocale ? colliculocale : "",
                                  fout);
        }
        else
        {
            if (!collcollate || !collctype || colliculocale ||
                strcmp(collcollate, collctype) != 0)
                pg_log_warning("invalid collation \"%s\"", qcollname);
 
            appendPQExpBufferStr(q, ", locale = ");
            appendStringLiteralAH(q, collcollate ? collcollate : "", fout);
        }
 
        if (collicurules)
        {
            appendPQExpBufferStr(q, ", rules = ");
            appendStringLiteralAH(q, collicurules ? collicurules : "", fout);
        }
    }
    else if (collprovider[0] == 'c')
    {
        if (colliculocale || collicurules || !collcollate || !collctype)
            pg_log_warning("invalid collation \"%s\"", qcollname);
 
        if (collcollate && collctype && strcmp(collcollate, collctype) == 0)
        {
            appendPQExpBufferStr(q, ", locale = ");
            appendStringLiteralAH(q, collcollate ? collcollate : "", fout);
        }
        else
        {
            appendPQExpBufferStr(q, ", lc_collate = ");
            appendStringLiteralAH(q, collcollate ? collcollate : "", fout);
            appendPQExpBufferStr(q, ", lc_ctype = ");
            appendStringLiteralAH(q, collctype ? collctype : "", fout);
        }
    }
    else
        pg_fatal("unrecognized collation provider: %s", collprovider);
 
    /*
     * For binary upgrade, carry over the collation version.  For normal
     * dump/restore, omit the version, so that it is computed upon restore.
     */
    if (dopt->binary_upgrade)
    {
        int         i_collversion;
 
        i_collversion = PQfnumber(res, "collversion");
        if (!PQgetisnull(res, 0, i_collversion))
        {
            appendPQExpBufferStr(q, ", version = ");
            appendStringLiteralAH(q,
                                  PQgetvalue(res, 0, i_collversion),
                                  fout);
        }
    }
 
    appendPQExpBufferStr(q, ");\n");
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(q, &collinfo->dobj,
                                        "COLLATION", qcollname,
                                        collinfo->dobj.namespace->dobj.name);
 
    if (collinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, collinfo->dobj.catId, collinfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = collinfo->dobj.name,
                                  .namespace = collinfo->dobj.namespace->dobj.name,
                                  .owner = collinfo->rolname,
                                  .description = "COLLATION",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
    /* Dump Collation Comments */
    if (collinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "COLLATION", qcollname,
                    collinfo->dobj.namespace->dobj.name, collinfo->rolname,
                    collinfo->dobj.catId, 0, collinfo->dobj.dumpId);
 
    PQclear(res);
 
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    free(qcollname);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), _collInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQueryForSingleRow(), fmtId(), fmtQualifiedDumpable, free, _dumpableObject::name, CatalogId::oid, pg_fatal, pg_log_warning, pg_strdup(), PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), Archive::remoteVersion, res, _collInfo::rolname, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

dumpComment()

static void dumpComment ( Archive *  fout, const char *  type, const char *  name, const char *  namespace, const char *  owner, CatalogId  catalogId, int  subid, DumpId  dumpId  )

inlinestatic

Definition at line 9980 of file pg_dump.c.

{
    dumpCommentExtended(fout, type, name, namespace, owner,
                        catalogId, subid, dumpId, NULL);
}

References dumpCommentExtended(), name, and type.

Referenced by dumpAccessMethod(), dumpAgg(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpConversion(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpLO(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpRangeType(), dumpRule(), dumpSequence(), dumpStatisticsExt(), dumpSubscription(), dumpTableConstraintComment(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), and dumpUndefinedType().

dumpCommentExtended()

static void dumpCommentExtended ( Archive *  fout, const char *  type, const char *  name, const char *  namespace, const char *  owner, CatalogId  catalogId, int  subid, DumpId  dumpId, const char *  initdb_comment  )

static

Definition at line 9880 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    CommentItem *comments;
    int         ncomments;
 
    /* do nothing, if --no-comments is supplied */
    if (dopt->no_comments)
        return;
 
    /* Comments are schema not data ... except LO comments are data */
    if (strcmp(type, "LARGE OBJECT") != 0)
    {
        if (dopt->dataOnly)
            return;
    }
    else
    {
        /* We do dump LO comments in binary-upgrade mode */
        if (dopt->schemaOnly && !dopt->binary_upgrade)
            return;
    }
 
    /* Search for comments associated with catalogId, using table */
    ncomments = findComments(catalogId.tableoid, catalogId.oid,
                             &comments);
 
    /* Is there one matching the subid? */
    while (ncomments > 0)
    {
        if (comments->objsubid == subid)
            break;
        comments++;
        ncomments--;
    }
 
    if (initdb_comment != NULL)
    {
        static CommentItem empty_comment = {.descr = ""};
 
        /*
         * initdb creates this object with a comment.  Skip dumping the
         * initdb-provided comment, which would complicate matters for
         * non-superuser use of pg_dump.  When the DBA has removed initdb's
         * comment, replicate that.
         */
        if (ncomments == 0)
        {
            comments = &empty_comment;
            ncomments = 1;
        }
        else if (strcmp(comments->descr, initdb_comment) == 0)
            ncomments = 0;
    }
 
    /* If a comment exists, build COMMENT ON statement */
    if (ncomments > 0)
    {
        PQExpBuffer query = createPQExpBuffer();
        PQExpBuffer tag = createPQExpBuffer();
 
        appendPQExpBuffer(query, "COMMENT ON %s ", type);
        if (namespace && *namespace)
            appendPQExpBuffer(query, "%s.", fmtId(namespace));
        appendPQExpBuffer(query, "%s IS ", name);
        appendStringLiteralAH(query, comments->descr, fout);
        appendPQExpBufferStr(query, ";\n");
 
        appendPQExpBuffer(tag, "%s %s", type, name);
 
        /*
         * We mark comments as SECTION_NONE because they really belong in the
         * same section as their parent, whether that is pre-data or
         * post-data.
         */
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     ARCHIVE_OPTS(.tag = tag->data,
                                  .namespace = namespace,
                                  .owner = owner,
                                  .description = "COMMENT",
                                  .section = SECTION_NONE,
                                  .createStmt = query->data,
                                  .deps = &dumpId,
                                  .nDeps = 1));
 
        destroyPQExpBuffer(query);
        destroyPQExpBuffer(tag);
    }
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, comments, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, CommentItem::descr, destroyPQExpBuffer(), Archive::dopt, findComments(), fmtId(), name, ncomments, nilCatalogId, _dumpOptions::no_comments, CommentItem::objsubid, CatalogId::oid, _dumpOptions::schemaOnly, SECTION_NONE, CatalogId::tableoid, and type.

Referenced by dumpComment(), and dumpNamespace().

dumpCompositeType()

static void dumpCompositeType ( Archive *  fout, const TypeInfo *  tyinfo  )

static

Definition at line 11460 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer dropped = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    char       *qtypname;
    char       *qualtypname;
    int         ntups;
    int         i_attname;
    int         i_atttypdefn;
    int         i_attlen;
    int         i_attalign;
    int         i_attisdropped;
    int         i_attcollation;
    int         i;
    int         actual_atts;
 
    if (!fout->is_prepared[PREPQUERY_DUMPCOMPOSITETYPE])
    {
        /*
         * Set up query for type-specific details.
         *
         * Since we only want to dump COLLATE clauses for attributes whose
         * collation is different from their type's default, we use a CASE
         * here to suppress uninteresting attcollations cheaply.  atttypid
         * will be 0 for dropped columns; collation does not matter for those.
         */
        appendPQExpBufferStr(query,
                             "PREPARE dumpCompositeType(pg_catalog.oid) AS\n"
                             "SELECT a.attname, a.attnum, "
                             "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
                             "a.attlen, a.attalign, a.attisdropped, "
                             "CASE WHEN a.attcollation <> at.typcollation "
                             "THEN a.attcollation ELSE 0 END AS attcollation "
                             "FROM pg_catalog.pg_type ct "
                             "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
                             "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
                             "WHERE ct.oid = $1 "
                             "ORDER BY a.attnum");
 
        ExecuteSqlStatement(fout, query->data);
 
        fout->is_prepared[PREPQUERY_DUMPCOMPOSITETYPE] = true;
    }
 
    printfPQExpBuffer(query,
                      "EXECUTE dumpCompositeType('%u')",
                      tyinfo->dobj.catId.oid);
 
    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
 
    ntups = PQntuples(res);
 
    i_attname = PQfnumber(res, "attname");
    i_atttypdefn = PQfnumber(res, "atttypdefn");
    i_attlen = PQfnumber(res, "attlen");
    i_attalign = PQfnumber(res, "attalign");
    i_attisdropped = PQfnumber(res, "attisdropped");
    i_attcollation = PQfnumber(res, "attcollation");
 
    if (dopt->binary_upgrade)
    {
        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                                 tyinfo->dobj.catId.oid,
                                                 false, false);
        binary_upgrade_set_pg_class_oids(fout, q, tyinfo->typrelid, false);
    }
 
    qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
    qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
 
    appendPQExpBuffer(q, "CREATE TYPE %s AS (",
                      qualtypname);
 
    actual_atts = 0;
    for (i = 0; i < ntups; i++)
    {
        char       *attname;
        char       *atttypdefn;
        char       *attlen;
        char       *attalign;
        bool        attisdropped;
        Oid         attcollation;
 
        attname = PQgetvalue(res, i, i_attname);
        atttypdefn = PQgetvalue(res, i, i_atttypdefn);
        attlen = PQgetvalue(res, i, i_attlen);
        attalign = PQgetvalue(res, i, i_attalign);
        attisdropped = (PQgetvalue(res, i, i_attisdropped)[0] == 't');
        attcollation = atooid(PQgetvalue(res, i, i_attcollation));
 
        if (attisdropped && !dopt->binary_upgrade)
            continue;
 
        /* Format properly if not first attr */
        if (actual_atts++ > 0)
            appendPQExpBufferChar(q, ',');
        appendPQExpBufferStr(q, "\n\t");
 
        if (!attisdropped)
        {
            appendPQExpBuffer(q, "%s %s", fmtId(attname), atttypdefn);
 
            /* Add collation if not default for the column type */
            if (OidIsValid(attcollation))
            {
                CollInfo   *coll;
 
                coll = findCollationByOid(attcollation);
                if (coll)
                    appendPQExpBuffer(q, " COLLATE %s",
                                      fmtQualifiedDumpable(coll));
            }
        }
        else
        {
            /*
             * This is a dropped attribute and we're in binary_upgrade mode.
             * Insert a placeholder for it in the CREATE TYPE command, and set
             * length and alignment with direct UPDATE to the catalogs
             * afterwards. See similar code in dumpTableSchema().
             */
            appendPQExpBuffer(q, "%s INTEGER /* dummy */", fmtId(attname));
 
            /* stash separately for insertion after the CREATE TYPE */
            appendPQExpBufferStr(dropped,
                                 "\n-- For binary upgrade, recreate dropped column.\n");
            appendPQExpBuffer(dropped, "UPDATE pg_catalog.pg_attribute\n"
                              "SET attlen = %s, "
                              "attalign = '%s', attbyval = false\n"
                              "WHERE attname = ", attlen, attalign);
            appendStringLiteralAH(dropped, attname, fout);
            appendPQExpBufferStr(dropped, "\n  AND attrelid = ");
            appendStringLiteralAH(dropped, qualtypname, fout);
            appendPQExpBufferStr(dropped, "::pg_catalog.regclass;\n");
 
            appendPQExpBuffer(dropped, "ALTER TYPE %s ",
                              qualtypname);
            appendPQExpBuffer(dropped, "DROP ATTRIBUTE %s;\n",
                              fmtId(attname));
        }
    }
    appendPQExpBufferStr(q, "\n);\n");
    appendPQExpBufferStr(q, dropped->data);
 
    appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj,
                                        "TYPE", qtypname,
                                        tyinfo->dobj.namespace->dobj.name);
 
    if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
                                  .namespace = tyinfo->dobj.namespace->dobj.name,
                                  .owner = tyinfo->rolname,
                                  .description = "TYPE",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
 
    /* Dump Type Comments and Security Labels */
    if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "TYPE", qtypname,
                    tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                    tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
 
    if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
        dumpSecLabel(fout, "TYPE", qtypname,
                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
 
    if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
        dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
                qtypname, NULL,
                tyinfo->dobj.namespace->dobj.name,
                tyinfo->rolname, &tyinfo->dacl);
 
    /* Dump any per-column comments */
    if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpCompositeTypeColComments(fout, tyinfo, res);
 
    PQclear(res);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(dropped);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(query);
    free(qtypname);
    free(qualtypname);
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, attalign, attlen, attname, _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_type_oid(), _dumpableObject::catId, createPQExpBuffer(), _typeInfo::dacl, PQExpBufferData::data, destroyPQExpBuffer(), _typeInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_ACL, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, DUMP_COMPONENT_SECLABEL, dumpACL(), dumpComment(), dumpCompositeTypeColComments(), _dumpableObject::dumpId, dumpSecLabel(), ExecuteSqlQuery(), ExecuteSqlStatement(), findCollationByOid(), fmtId(), fmtQualifiedDumpable, free, i, InvalidDumpId, Archive::is_prepared, _dumpableObject::name, CatalogId::oid, OidIsValid, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), PREPQUERY_DUMPCOMPOSITETYPE, printfPQExpBuffer(), res, _typeInfo::rolname, SECTION_PRE_DATA, and _typeInfo::typrelid.

Referenced by dumpType().

dumpCompositeTypeColComments()

static void dumpCompositeTypeColComments ( Archive *  fout, const TypeInfo *  tyinfo, PGresult *  res  )

static

Definition at line 11666 of file pg_dump.c.

{
    CommentItem *comments;
    int         ncomments;
    PQExpBuffer query;
    PQExpBuffer target;
    int         i;
    int         ntups;
    int         i_attname;
    int         i_attnum;
    int         i_attisdropped;
 
    /* do nothing, if --no-comments is supplied */
    if (fout->dopt->no_comments)
        return;
 
    /* Search for comments associated with type's pg_class OID */
    ncomments = findComments(RelationRelationId, tyinfo->typrelid,
                             &comments);
 
    /* If no comments exist, we're done */
    if (ncomments <= 0)
        return;
 
    /* Build COMMENT ON statements */
    query = createPQExpBuffer();
    target = createPQExpBuffer();
 
    ntups = PQntuples(res);
    i_attnum = PQfnumber(res, "attnum");
    i_attname = PQfnumber(res, "attname");
    i_attisdropped = PQfnumber(res, "attisdropped");
    while (ncomments > 0)
    {
        const char *attname;
 
        attname = NULL;
        for (i = 0; i < ntups; i++)
        {
            if (atoi(PQgetvalue(res, i, i_attnum)) == comments->objsubid &&
                PQgetvalue(res, i, i_attisdropped)[0] != 't')
            {
                attname = PQgetvalue(res, i, i_attname);
                break;
            }
        }
        if (attname)            /* just in case we don't find it */
        {
            const char *descr = comments->descr;
 
            resetPQExpBuffer(target);
            appendPQExpBuffer(target, "COLUMN %s.",
                              fmtId(tyinfo->dobj.name));
            appendPQExpBufferStr(target, fmtId(attname));
 
            resetPQExpBuffer(query);
            appendPQExpBuffer(query, "COMMENT ON COLUMN %s.",
                              fmtQualifiedDumpable(tyinfo));
            appendPQExpBuffer(query, "%s IS ", fmtId(attname));
            appendStringLiteralAH(query, descr, fout);
            appendPQExpBufferStr(query, ";\n");
 
            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         ARCHIVE_OPTS(.tag = target->data,
                                      .namespace = tyinfo->dobj.namespace->dobj.name,
                                      .owner = tyinfo->rolname,
                                      .description = "COMMENT",
                                      .section = SECTION_NONE,
                                      .createStmt = query->data,
                                      .deps = &(tyinfo->dobj.dumpId),
                                      .nDeps = 1));
        }
 
        comments++;
        ncomments--;
    }
 
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(target);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), attname, comments, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), _typeInfo::dobj, Archive::dopt, _dumpableObject::dumpId, findComments(), fmtId(), fmtQualifiedDumpable, i, _dumpableObject::name, ncomments, nilCatalogId, _dumpOptions::no_comments, CommentItem::objsubid, PQfnumber(), PQgetvalue(), PQntuples(), res, resetPQExpBuffer(), _typeInfo::rolname, SECTION_NONE, and _typeInfo::typrelid.

Referenced by dumpCompositeType().

dumpConstraint()

static void dumpConstraint ( Archive *  fout, const ConstraintInfo *  coninfo  )

static

Definition at line 16855 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    TableInfo  *tbinfo = coninfo->contable;
    PQExpBuffer q;
    PQExpBuffer delq;
    char       *tag = NULL;
    char       *foreign;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
 
    foreign = tbinfo &&
        tbinfo->relkind == RELKIND_FOREIGN_TABLE ? "FOREIGN " : "";
 
    if (coninfo->contype == 'p' ||
        coninfo->contype == 'u' ||
        coninfo->contype == 'x')
    {
        /* Index-related constraint */
        IndxInfo   *indxinfo;
        int         k;
 
        indxinfo = (IndxInfo *) findObjectByDumpId(coninfo->conindex);
 
        if (indxinfo == NULL)
            pg_fatal("missing index for constraint \"%s\"",
                     coninfo->dobj.name);
 
        if (dopt->binary_upgrade)
            binary_upgrade_set_pg_class_oids(fout, q,
                                             indxinfo->dobj.catId.oid, true);
 
        appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s\n", foreign,
                          fmtQualifiedDumpable(tbinfo));
        appendPQExpBuffer(q, "    ADD CONSTRAINT %s ",
                          fmtId(coninfo->dobj.name));
 
        if (coninfo->condef)
        {
            /* pg_get_constraintdef should have provided everything */
            appendPQExpBuffer(q, "%s;\n", coninfo->condef);
        }
        else
        {
            appendPQExpBufferStr(q,
                                 coninfo->contype == 'p' ? "PRIMARY KEY" : "UNIQUE");
 
            /*
             * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
             * indexes. Being able to create this was fixed, but we need to
             * make the index distinct in order to be able to restore the
             * dump.
             */
            if (indxinfo->indnullsnotdistinct && coninfo->contype != 'p')
                appendPQExpBufferStr(q, " NULLS NOT DISTINCT");
            appendPQExpBufferStr(q, " (");
            for (k = 0; k < indxinfo->indnkeyattrs; k++)
            {
                int         indkey = (int) indxinfo->indkeys[k];
                const char *attname;
 
                if (indkey == InvalidAttrNumber)
                    break;
                attname = getAttrName(indkey, tbinfo);
 
                appendPQExpBuffer(q, "%s%s",
                                  (k == 0) ? "" : ", ",
                                  fmtId(attname));
            }
 
            if (indxinfo->indnkeyattrs < indxinfo->indnattrs)
                appendPQExpBufferStr(q, ") INCLUDE (");
 
            for (k = indxinfo->indnkeyattrs; k < indxinfo->indnattrs; k++)
            {
                int         indkey = (int) indxinfo->indkeys[k];
                const char *attname;
 
                if (indkey == InvalidAttrNumber)
                    break;
                attname = getAttrName(indkey, tbinfo);
 
                appendPQExpBuffer(q, "%s%s",
                                  (k == indxinfo->indnkeyattrs) ? "" : ", ",
                                  fmtId(attname));
            }
 
            appendPQExpBufferChar(q, ')');
 
            if (nonemptyReloptions(indxinfo->indreloptions))
            {
                appendPQExpBufferStr(q, " WITH (");
                appendReloptionsArrayAH(q, indxinfo->indreloptions, "", fout);
                appendPQExpBufferChar(q, ')');
            }
 
            if (coninfo->condeferrable)
            {
                appendPQExpBufferStr(q, " DEFERRABLE");
                if (coninfo->condeferred)
                    appendPQExpBufferStr(q, " INITIALLY DEFERRED");
            }
 
            appendPQExpBufferStr(q, ";\n");
        }
 
        /*
         * Append ALTER TABLE commands as needed to set properties that we
         * only have ALTER TABLE syntax for.  Keep this in sync with the
         * similar code in dumpIndex!
         */
 
        /* Drop any not-null constraints that were added to support the PK */
        if (coninfo->contype == 'p')
            for (int i = 0; i < tbinfo->numatts; i++)
                if (tbinfo->notnull_throwaway[i])
                    appendPQExpBuffer(q, "\nALTER TABLE ONLY %s DROP CONSTRAINT %s;",
                                      fmtQualifiedDumpable(tbinfo),
                                      tbinfo->notnull_constrs[i]);
 
        /* If the index is clustered, we need to record that. */
        if (indxinfo->indisclustered)
        {
            appendPQExpBuffer(q, "\nALTER TABLE %s CLUSTER",
                              fmtQualifiedDumpable(tbinfo));
            /* index name is not qualified in this syntax */
            appendPQExpBuffer(q, " ON %s;\n",
                              fmtId(indxinfo->dobj.name));
        }
 
        /* If the index defines identity, we need to record that. */
        if (indxinfo->indisreplident)
        {
            appendPQExpBuffer(q, "\nALTER TABLE ONLY %s REPLICA IDENTITY USING",
                              fmtQualifiedDumpable(tbinfo));
            /* index name is not qualified in this syntax */
            appendPQExpBuffer(q, " INDEX %s;\n",
                              fmtId(indxinfo->dobj.name));
        }
 
        /* Indexes can depend on extensions */
        append_depends_on_extension(fout, q, &indxinfo->dobj,
                                    "pg_catalog.pg_class", "INDEX",
                                    fmtQualifiedDumpable(indxinfo));
 
        appendPQExpBuffer(delq, "ALTER %sTABLE ONLY %s ", foreign,
                          fmtQualifiedDumpable(tbinfo));
        appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                          fmtId(coninfo->dobj.name));
 
        tag = psprintf("%s %s", tbinfo->dobj.name, coninfo->dobj.name);
 
        if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
            ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                         ARCHIVE_OPTS(.tag = tag,
                                      .namespace = tbinfo->dobj.namespace->dobj.name,
                                      .tablespace = indxinfo->tablespace,
                                      .owner = tbinfo->rolname,
                                      .description = "CONSTRAINT",
                                      .section = SECTION_POST_DATA,
                                      .createStmt = q->data,
                                      .dropStmt = delq->data));
    }
    else if (coninfo->contype == 'f')
    {
        char       *only;
 
        /*
         * Foreign keys on partitioned tables are always declared as
         * inheriting to partitions; for all other cases, emit them as
         * applying ONLY directly to the named table, because that's how they
         * work for regular inherited tables.
         */
        only = tbinfo->relkind == RELKIND_PARTITIONED_TABLE ? "" : "ONLY ";
 
        /*
         * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
         * current table data is not processed
         */
        appendPQExpBuffer(q, "ALTER %sTABLE %s%s\n", foreign,
                          only, fmtQualifiedDumpable(tbinfo));
        appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
                          fmtId(coninfo->dobj.name),
                          coninfo->condef);
 
        appendPQExpBuffer(delq, "ALTER %sTABLE %s%s ", foreign,
                          only, fmtQualifiedDumpable(tbinfo));
        appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                          fmtId(coninfo->dobj.name));
 
        tag = psprintf("%s %s", tbinfo->dobj.name, coninfo->dobj.name);
 
        if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
            ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                         ARCHIVE_OPTS(.tag = tag,
                                      .namespace = tbinfo->dobj.namespace->dobj.name,
                                      .owner = tbinfo->rolname,
                                      .description = "FK CONSTRAINT",
                                      .section = SECTION_POST_DATA,
                                      .createStmt = q->data,
                                      .dropStmt = delq->data));
    }
    else if (coninfo->contype == 'c' && tbinfo)
    {
        /* CHECK constraint on a table */
 
        /* Ignore if not to be dumped separately, or if it was inherited */
        if (coninfo->separate && coninfo->conislocal)
        {
            /* not ONLY since we want it to propagate to children */
            appendPQExpBuffer(q, "ALTER %sTABLE %s\n", foreign,
                              fmtQualifiedDumpable(tbinfo));
            appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
                              fmtId(coninfo->dobj.name),
                              coninfo->condef);
 
            appendPQExpBuffer(delq, "ALTER %sTABLE %s ", foreign,
                              fmtQualifiedDumpable(tbinfo));
            appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                              fmtId(coninfo->dobj.name));
 
            tag = psprintf("%s %s", tbinfo->dobj.name, coninfo->dobj.name);
 
            if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
                ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                             ARCHIVE_OPTS(.tag = tag,
                                          .namespace = tbinfo->dobj.namespace->dobj.name,
                                          .owner = tbinfo->rolname,
                                          .description = "CHECK CONSTRAINT",
                                          .section = SECTION_POST_DATA,
                                          .createStmt = q->data,
                                          .dropStmt = delq->data));
        }
    }
    else if (coninfo->contype == 'c' && tbinfo == NULL)
    {
        /* CHECK constraint on a domain */
        TypeInfo   *tyinfo = coninfo->condomain;
 
        /* Ignore if not to be dumped separately */
        if (coninfo->separate)
        {
            appendPQExpBuffer(q, "ALTER DOMAIN %s\n",
                              fmtQualifiedDumpable(tyinfo));
            appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
                              fmtId(coninfo->dobj.name),
                              coninfo->condef);
 
            appendPQExpBuffer(delq, "ALTER DOMAIN %s ",
                              fmtQualifiedDumpable(tyinfo));
            appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                              fmtId(coninfo->dobj.name));
 
            tag = psprintf("%s %s", tyinfo->dobj.name, coninfo->dobj.name);
 
            if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
                ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                             ARCHIVE_OPTS(.tag = tag,
                                          .namespace = tyinfo->dobj.namespace->dobj.name,
                                          .owner = tyinfo->rolname,
                                          .description = "CHECK CONSTRAINT",
                                          .section = SECTION_POST_DATA,
                                          .createStmt = q->data,
                                          .dropStmt = delq->data));
        }
    }
    else
    {
        pg_fatal("unrecognized constraint type: %c",
                 coninfo->contype);
    }
 
    /* Dump Constraint Comments --- only works for table constraints */
    if (tbinfo && coninfo->separate &&
        coninfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpTableConstraintComment(fout, coninfo);
 
    free(tag);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
}

References append_depends_on_extension(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendReloptionsArrayAH(), ARCHIVE_OPTS, ArchiveEntry(), attname, _dumpOptions::binary_upgrade, binary_upgrade_set_pg_class_oids(), _dumpableObject::catId, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::conindex, _constraintInfo::conislocal, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), _typeInfo::dobj, _tableInfo::dobj, _indxInfo::dobj, _constraintInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, _dumpableObject::dumpId, dumpTableConstraintComment(), findObjectByDumpId(), fmtId(), fmtQualifiedDumpable, free, getAttrName(), i, if(), _indxInfo::indisclustered, _indxInfo::indisreplident, _indxInfo::indkeys, _indxInfo::indnattrs, _indxInfo::indnkeyattrs, _indxInfo::indnullsnotdistinct, _indxInfo::indreloptions, InvalidAttrNumber, _dumpableObject::name, nonemptyReloptions(), _tableInfo::notnull_constrs, _tableInfo::notnull_throwaway, _tableInfo::numatts, CatalogId::oid, pg_fatal, psprintf(), _tableInfo::relkind, _typeInfo::rolname, _tableInfo::rolname, SECTION_POST_DATA, _constraintInfo::separate, and _indxInfo::tablespace.

Referenced by dumpDumpableObject().

dumpConversion()

static void dumpConversion ( Archive *  fout, const ConvInfo *  convinfo  )

static

Definition at line 13758 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    char       *qconvname;
    PGresult   *res;
    int         i_conforencoding;
    int         i_contoencoding;
    int         i_conproc;
    int         i_condefault;
    const char *conforencoding;
    const char *contoencoding;
    const char *conproc;
    bool        condefault;
 
    /* Do nothing in data-only dump */
    if (dopt->dataOnly)
        return;
 
    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
 
    qconvname = pg_strdup(fmtId(convinfo->dobj.name));
 
    /* Get conversion-specific details */
    appendPQExpBuffer(query, "SELECT "
                      "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
                      "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
                      "conproc, condefault "
                      "FROM pg_catalog.pg_conversion c "
                      "WHERE c.oid = '%u'::pg_catalog.oid",
                      convinfo->dobj.catId.oid);
 
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
 
    i_conforencoding = PQfnumber(res, "conforencoding");
    i_contoencoding = PQfnumber(res, "contoencoding");
    i_conproc = PQfnumber(res, "conproc");
    i_condefault = PQfnumber(res, "condefault");
 
    conforencoding = PQgetvalue(res, 0, i_conforencoding);
    contoencoding = PQgetvalue(res, 0, i_contoencoding);
    conproc = PQgetvalue(res, 0, i_conproc);
    condefault = (PQgetvalue(res, 0, i_condefault)[0] == 't');
 
    appendPQExpBuffer(delq, "DROP CONVERSION %s;\n",
                      fmtQualifiedDumpable(convinfo));
 
    appendPQExpBuffer(q, "CREATE %sCONVERSION %s FOR ",
                      (condefault) ? "DEFAULT " : "",
                      fmtQualifiedDumpable(convinfo));
    appendStringLiteralAH(q, conforencoding, fout);
    appendPQExpBufferStr(q, " TO ");
    appendStringLiteralAH(q, contoencoding, fout);
    /* regproc output is already sufficiently quoted */
    appendPQExpBuffer(q, " FROM %s;\n", conproc);
 
    if (dopt->binary_upgrade)
        binary_upgrade_extension_member(q, &convinfo->dobj,
                                        "CONVERSION", qconvname,
                                        convinfo->dobj.namespace->dobj.name);
 
    if (convinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
        ArchiveEntry(fout, convinfo->dobj.catId, convinfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = convinfo->dobj.name,
                                  .namespace = convinfo->dobj.namespace->dobj.name,
                                  .owner = convinfo->rolname,
                                  .description = "CONVERSION",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = q->data,
                                  .dropStmt = delq->data));
 
    /* Dump Conversion Comments */
    if (convinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
        dumpComment(fout, "CONVERSION", qconvname,
                    convinfo->dobj.namespace->dobj.name, convinfo->rolname,
                    convinfo->dobj.catId, 0, convinfo->dobj.dumpId);
 
    PQclear(res);
 
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    free(qconvname);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), _dumpOptions::binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpOptions::dataOnly, destroyPQExpBuffer(), _convInfo::dobj, Archive::dopt, _dumpableObject::dump, DUMP_COMPONENT_COMMENT, DUMP_COMPONENT_DEFINITION, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQueryForSingleRow(), fmtId(), fmtQualifiedDumpable, free, _dumpableObject::name, CatalogId::oid, pg_strdup(), PQclear(), PQfnumber(), PQgetvalue(), res, _convInfo::rolname, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

dumpDatabase()

static void dumpDatabase ( Archive *  fout )

static

Definition at line 2936 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer dbQry = createPQExpBuffer();
    PQExpBuffer delQry = createPQExpBuffer();
    PQExpBuffer creaQry = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    PGconn     *conn = GetConnection(fout);
    PGresult   *res;
    int         i_tableoid,
                i_oid,
                i_datname,
                i_datdba,
                i_encoding,
                i_datlocprovider,
                i_collate,
                i_ctype,
                i_daticulocale,
                i_daticurules,
                i_frozenxid,
                i_minmxid,
                i_datacl,
                i_acldefault,
                i_datistemplate,
                i_datconnlimit,
                i_datcollversion,
                i_tablespace;
    CatalogId   dbCatId;
    DumpId      dbDumpId;
    DumpableAcl dbdacl;
    const char *datname,
               *dba,
               *encoding,
               *datlocprovider,
               *collate,
               *ctype,
               *iculocale,
               *icurules,
               *datistemplate,
               *datconnlimit,
               *tablespace;
    uint32      frozenxid,
                minmxid;
    char       *qdatname;
 
    pg_log_info("saving database definition");
 
    /*
     * Fetch the database-level properties for this database.
     */
    appendPQExpBufferStr(dbQry, "SELECT tableoid, oid, datname, "
                         "datdba, "
                         "pg_encoding_to_char(encoding) AS encoding, "
                         "datcollate, datctype, datfrozenxid, "
                         "datacl, acldefault('d', datdba) AS acldefault, "
                         "datistemplate, datconnlimit, ");
    if (fout->remoteVersion >= 90300)
        appendPQExpBufferStr(dbQry, "datminmxid, ");
    else
        appendPQExpBufferStr(dbQry, "0 AS datminmxid, ");
    if (fout->remoteVersion >= 150000)
        appendPQExpBufferStr(dbQry, "datlocprovider, daticulocale, datcollversion, ");
    else
        appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS daticulocale, NULL AS datcollversion, ");
    if (fout->remoteVersion >= 160000)
        appendPQExpBufferStr(dbQry, "daticurules, ");
    else
        appendPQExpBufferStr(dbQry, "NULL AS daticurules, ");
    appendPQExpBufferStr(dbQry,
                         "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
                         "shobj_description(oid, 'pg_database') AS description "
                         "FROM pg_database "
                         "WHERE datname = current_database()");
 
    res = ExecuteSqlQueryForSingleRow(fout, dbQry->data);
 
    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_datname = PQfnumber(res, "datname");
    i_datdba = PQfnumber(res, "datdba");
    i_encoding = PQfnumber(res, "encoding");
    i_datlocprovider = PQfnumber(res, "datlocprovider");
    i_collate = PQfnumber(res, "datcollate");
    i_ctype = PQfnumber(res, "datctype");
    i_daticulocale = PQfnumber(res, "daticulocale");
    i_daticurules = PQfnumber(res, "daticurules");
    i_frozenxid = PQfnumber(res, "datfrozenxid");
    i_minmxid = PQfnumber(res, "datminmxid");
    i_datacl = PQfnumber(res, "datacl");
    i_acldefault = PQfnumber(res, "acldefault");
    i_datistemplate = PQfnumber(res, "datistemplate");
    i_datconnlimit = PQfnumber(res, "datconnlimit");
    i_datcollversion = PQfnumber(res, "datcollversion");
    i_tablespace = PQfnumber(res, "tablespace");
 
    dbCatId.tableoid = atooid(PQgetvalue(res, 0, i_tableoid));
    dbCatId.oid = atooid(PQgetvalue(res, 0, i_oid));
    datname = PQgetvalue(res, 0, i_datname);
    dba = getRoleName(PQgetvalue(res, 0, i_datdba));
    encoding = PQgetvalue(res, 0, i_encoding);
    datlocprovider = PQgetvalue(res, 0, i_datlocprovider);
    collate = PQgetvalue(res, 0, i_collate);
    ctype = PQgetvalue(res, 0, i_ctype);
    if (!PQgetisnull(res, 0, i_daticulocale))
        iculocale = PQgetvalue(res, 0, i_daticulocale);
    else
        iculocale = NULL;
    if (!PQgetisnull(res, 0, i_daticurules))
        icurules = PQgetvalue(res, 0, i_daticurules);
    else
        icurules = NULL;
    frozenxid = atooid(PQgetvalue(res, 0, i_frozenxid));
    minmxid = atooid(PQgetvalue(res, 0, i_minmxid));
    dbdacl.acl = PQgetvalue(res, 0, i_datacl);
    dbdacl.acldefault = PQgetvalue(res, 0, i_acldefault);
    datistemplate = PQgetvalue(res, 0, i_datistemplate);
    datconnlimit = PQgetvalue(res, 0, i_datconnlimit);
    tablespace = PQgetvalue(res, 0, i_tablespace);
 
    qdatname = pg_strdup(fmtId(datname));
 
    /*
     * Prepare the CREATE DATABASE command.  We must specify OID (if we want
     * to preserve that), as well as the encoding, locale, and tablespace
     * since those can't be altered later.  Other DB properties are left to
     * the DATABASE PROPERTIES entry, so that they can be applied after
     * reconnecting to the target DB.
     */
    if (dopt->binary_upgrade)
    {
        appendPQExpBuffer(creaQry, "CREATE DATABASE %s WITH TEMPLATE = template0 OID = %u",
                          qdatname, dbCatId.oid);
    }
    else
    {
        appendPQExpBuffer(creaQry, "CREATE DATABASE %s WITH TEMPLATE = template0",
                          qdatname);
    }
    if (strlen(encoding) > 0)
    {
        appendPQExpBufferStr(creaQry, " ENCODING = ");
        appendStringLiteralAH(creaQry, encoding, fout);
    }
 
    appendPQExpBufferStr(creaQry, " LOCALE_PROVIDER = ");
    if (datlocprovider[0] == 'c')
        appendPQExpBufferStr(creaQry, "libc");
    else if (datlocprovider[0] == 'i')
        appendPQExpBufferStr(creaQry, "icu");
    else
        pg_fatal("unrecognized locale provider: %s",
                 datlocprovider);
 
    if (strlen(collate) > 0 && strcmp(collate, ctype) == 0)
    {
        appendPQExpBufferStr(creaQry, " LOCALE = ");
        appendStringLiteralAH(creaQry, collate, fout);
    }
    else
    {
        if (strlen(collate) > 0)
        {
            appendPQExpBufferStr(creaQry, " LC_COLLATE = ");
            appendStringLiteralAH(creaQry, collate, fout);
        }
        if (strlen(ctype) > 0)
        {
            appendPQExpBufferStr(creaQry, " LC_CTYPE = ");
            appendStringLiteralAH(creaQry, ctype, fout);
        }
    }
    if (iculocale)
    {
        appendPQExpBufferStr(creaQry, " ICU_LOCALE = ");
        appendStringLiteralAH(creaQry, iculocale, fout);
    }
    if (icurules)
    {
        appendPQExpBufferStr(creaQry, " ICU_RULES = ");
        appendStringLiteralAH(creaQry, icurules, fout);
    }
 
    /*
     * For binary upgrade, carry over the collation version.  For normal
     * dump/restore, omit the version, so that it is computed upon restore.
     */
    if (dopt->binary_upgrade)
    {
        if (!PQgetisnull(res, 0, i_datcollversion))
        {
            appendPQExpBufferStr(creaQry, " COLLATION_VERSION = ");
            appendStringLiteralAH(creaQry,
                                  PQgetvalue(res, 0, i_datcollversion),
                                  fout);
        }
    }
 
    /*
     * Note: looking at dopt->outputNoTablespaces here is completely the wrong
     * thing; the decision whether to specify a tablespace should be left till
     * pg_restore, so that pg_restore --no-tablespaces applies.  Ideally we'd
     * label the DATABASE entry with the tablespace and let the normal
     * tablespace selection logic work ... but CREATE DATABASE doesn't pay
     * attention to default_tablespace, so that won't work.
     */
    if (strlen(tablespace) > 0 && strcmp(tablespace, "pg_default") != 0 &&
        !dopt->outputNoTablespaces)
        appendPQExpBuffer(creaQry, " TABLESPACE = %s",
                          fmtId(tablespace));
    appendPQExpBufferStr(creaQry, ";\n");
 
    appendPQExpBuffer(delQry, "DROP DATABASE %s;\n",
                      qdatname);
 
    dbDumpId = createDumpId();
 
    ArchiveEntry(fout,
                 dbCatId,       /* catalog ID */
                 dbDumpId,      /* dump ID */
                 ARCHIVE_OPTS(.tag = datname,
                              .owner = dba,
                              .description = "DATABASE",
                              .section = SECTION_PRE_DATA,
                              .createStmt = creaQry->data,
                              .dropStmt = delQry->data));
 
    /* Compute correct tag for archive entry */
    appendPQExpBuffer(labelq, "DATABASE %s", qdatname);
 
    /* Dump DB comment if any */
    {
        /*
         * 8.2 and up keep comments on shared objects in a shared table, so we
         * cannot use the dumpComment() code used for other database objects.
         * Be careful that the ArchiveEntry parameters match that function.
         */
        char       *comment = PQgetvalue(res, 0, PQfnumber(res, "description"));
 
        if (comment && *comment && !dopt->no_comments)
        {
            resetPQExpBuffer(dbQry);
 
            /*
             * Generates warning when loaded into a differently-named
             * database.
             */
            appendPQExpBuffer(dbQry, "COMMENT ON DATABASE %s IS ", qdatname);
            appendStringLiteralAH(dbQry, comment, fout);
            appendPQExpBufferStr(dbQry, ";\n");
 
            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         ARCHIVE_OPTS(.tag = labelq->data,
                                      .owner = dba,
                                      .description = "COMMENT",
                                      .section = SECTION_NONE,
                                      .createStmt = dbQry->data,
                                      .deps = &dbDumpId,
                                      .nDeps = 1));
        }
    }
 
    /* Dump DB security label, if enabled */
    if (!dopt->no_security_labels)
    {
        PGresult   *shres;
        PQExpBuffer seclabelQry;
 
        seclabelQry = createPQExpBuffer();
 
        buildShSecLabelQuery("pg_database", dbCatId.oid, seclabelQry);
        shres = ExecuteSqlQuery(fout, seclabelQry->data, PGRES_TUPLES_OK);
        resetPQExpBuffer(seclabelQry);
        emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
        if (seclabelQry->len > 0)
            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         ARCHIVE_OPTS(.tag = labelq->data,
                                      .owner = dba,
                                      .description = "SECURITY LABEL",
                                      .section = SECTION_NONE,
                                      .createStmt = seclabelQry->data,
                                      .deps = &dbDumpId,
                                      .nDeps = 1));
        destroyPQExpBuffer(seclabelQry);
        PQclear(shres);
    }
 
    /*
     * Dump ACL if any.  Note that we do not support initial privileges
     * (pg_init_privs) on databases.
     */
    dbdacl.privtype = 0;
    dbdacl.initprivs = NULL;
 
    dumpACL(fout, dbDumpId, InvalidDumpId, "DATABASE",
            qdatname, NULL, NULL,
            dba, &dbdacl);
 
    /*
     * Now construct a DATABASE PROPERTIES archive entry to restore any
     * non-default database-level properties.  (The reason this must be
     * separate is that we cannot put any additional commands into the TOC
     * entry that has CREATE DATABASE.  pg_restore would execute such a group
     * in an implicit transaction block, and the backend won't allow CREATE
     * DATABASE in that context.)
     */
    resetPQExpBuffer(creaQry);
    resetPQExpBuffer(delQry);
 
    if (strlen(datconnlimit) > 0 && strcmp(datconnlimit, "-1") != 0)
        appendPQExpBuffer(creaQry, "ALTER DATABASE %s CONNECTION LIMIT = %s;\n",
                          qdatname, datconnlimit);
 
    if (strcmp(datistemplate, "t") == 0)
    {
        appendPQExpBuffer(creaQry, "ALTER DATABASE %s IS_TEMPLATE = true;\n",
                          qdatname);
 
        /*
         * The backend won't accept DROP DATABASE on a template database.  We
         * can deal with that by removing the template marking before the DROP
         * gets issued.  We'd prefer to use ALTER DATABASE IF EXISTS here, but
         * since no such command is currently supported, fake it with a direct
         * UPDATE on pg_database.
         */
        appendPQExpBufferStr(delQry, "UPDATE pg_catalog.pg_database "
                             "SET datistemplate = false WHERE datname = ");
        appendStringLiteralAH(delQry, datname, fout);
        appendPQExpBufferStr(delQry, ";\n");
    }
 
    /* Add database-specific SET options */
    dumpDatabaseConfig(fout, creaQry, datname, dbCatId.oid);
 
    /*
     * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
     * entry, too, for lack of a better place.
     */
    if (dopt->binary_upgrade)
    {
        appendPQExpBufferStr(creaQry, "\n-- For binary upgrade, set datfrozenxid and datminmxid.\n");
        appendPQExpBuffer(creaQry, "UPDATE pg_catalog.pg_database\n"
                          "SET datfrozenxid = '%u', datminmxid = '%u'\n"
                          "WHERE datname = ",
                          frozenxid, minmxid);
        appendStringLiteralAH(creaQry, datname, fout);
        appendPQExpBufferStr(creaQry, ";\n");
    }
 
    if (creaQry->len > 0)
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     ARCHIVE_OPTS(.tag = datname,
                                  .owner = dba,
                                  .description = "DATABASE PROPERTIES",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = creaQry->data,
                                  .dropStmt = delQry->data,
                                  .deps = &dbDumpId));
 
    /*
     * pg_largeobject comes from the old system intact, so set its
     * relfrozenxids, relminmxids and relfilenode.
     */
    if (dopt->binary_upgrade)
    {
        PGresult   *lo_res;
        PQExpBuffer loFrozenQry = createPQExpBuffer();
        PQExpBuffer loOutQry = createPQExpBuffer();
        PQExpBuffer loHorizonQry = createPQExpBuffer();
        int         ii_relfrozenxid,
                    ii_relfilenode,
                    ii_oid,
                    ii_relminmxid;
 
        /*
         * pg_largeobject
         */
        if (fout->remoteVersion >= 90300)
            appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, relminmxid, relfilenode, oid\n"
                              "FROM pg_catalog.pg_class\n"
                              "WHERE oid IN (%u, %u);\n",
                              LargeObjectRelationId, LargeObjectLOidPNIndexId);
        else
            appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, 0 AS relminmxid, relfilenode, oid\n"
                              "FROM pg_catalog.pg_class\n"
                              "WHERE oid IN (%u, %u);\n",
                              LargeObjectRelationId, LargeObjectLOidPNIndexId);
 
        lo_res = ExecuteSqlQuery(fout, loFrozenQry->data, PGRES_TUPLES_OK);
 
        ii_relfrozenxid = PQfnumber(lo_res, "relfrozenxid");
        ii_relminmxid = PQfnumber(lo_res, "relminmxid");
        ii_relfilenode = PQfnumber(lo_res, "relfilenode");
        ii_oid = PQfnumber(lo_res, "oid");
 
        appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
        appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
        for (int i = 0; i < PQntuples(lo_res); ++i)
        {
            Oid         oid;
            RelFileNumber relfilenumber;
 
            appendPQExpBuffer(loHorizonQry, "UPDATE pg_catalog.pg_class\n"
                              "SET relfrozenxid = '%u', relminmxid = '%u'\n"
                              "WHERE oid = %u;\n",
                              atooid(PQgetvalue(lo_res, i, ii_relfrozenxid)),
                              atooid(PQgetvalue(lo_res, i, ii_relminmxid)),
                              atooid(PQgetvalue(lo_res, i, ii_oid)));
 
            oid = atooid(PQgetvalue(lo_res, i, ii_oid));
            relfilenumber = atooid(PQgetvalue(lo_res, i, ii_relfilenode));
 
            if (oid == LargeObjectRelationId)
                appendPQExpBuffer(loOutQry,
                                  "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
                                  relfilenumber);
            else if (oid == LargeObjectLOidPNIndexId)
                appendPQExpBuffer(loOutQry,
                                  "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
                                  relfilenumber);
        }
 
        appendPQExpBufferStr(loOutQry,
                             "TRUNCATE pg_catalog.pg_largeobject;\n");
        appendPQExpBufferStr(loOutQry, loHorizonQry->data);
 
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     ARCHIVE_OPTS(.tag = "pg_largeobject",
                                  .description = "pg_largeobject",
                                  .section = SECTION_PRE_DATA,
                                  .createStmt = loOutQry->data));
 
        PQclear(lo_res);
 
        destroyPQExpBuffer(loFrozenQry);
        destroyPQExpBuffer(loHorizonQry);
        destroyPQExpBuffer(loOutQry);
    }
 
    PQclear(res);
 
    free(qdatname);
    destroyPQExpBuffer(dbQry);
    destroyPQExpBuffer(delQry);
    destroyPQExpBuffer(creaQry);
    destroyPQExpBuffer(labelq);
}

References _dumpableAcl::acl, _dumpableAcl::acldefault, appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ARCHIVE_OPTS, ArchiveEntry(), atooid, _dumpOptions::binary_upgrade, buildShSecLabelQuery(), comment, conn, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, datconnlimit, datistemplate, datlocprovider, datname, description, destroyPQExpBuffer(), Archive::dopt, dumpACL(), dumpDatabaseConfig(), emitShSecLabels(), encoding, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fmtId(), free, GetConnection(), getRoleName(), i, _dumpableAcl::initprivs, InvalidDumpId, PQExpBufferData::len, nilCatalogId, _dumpOptions::no_comments, _dumpOptions::no_security_labels, CatalogId::oid, _dumpOptions::outputNoTablespaces, pg_fatal, pg_log_info, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), PQntuples(), _dumpableAcl::privtype, Archive::remoteVersion, res, resetPQExpBuffer(), SECTION_NONE, SECTION_PRE_DATA, CatalogId::tableoid, and tablespace.

Referenced by main().

dumpDatabaseConfig()

static void dumpDatabaseConfig ( Archive *  AH, PQExpBuffer  outbuf, const char *  dbname, Oid  dboid  )

static

Definition at line 3388 of file pg_dump.c.

{
    PGconn     *conn = GetConnection(AH);
    PQExpBuffer buf = createPQExpBuffer();
    PGresult   *res;
 
    /* First collect database-specific options */
    printfPQExpBuffer(buf, "SELECT unnest(setconfig) FROM pg_db_role_setting "
                      "WHERE setrole = 0 AND setdatabase = '%u'::oid",
                      dboid);
 
    res = ExecuteSqlQuery(AH, buf->data, PGRES_TUPLES_OK);
 
    for (int i = 0; i < PQntuples(res); i++)
        makeAlterConfigCommand(conn, PQgetvalue(res, i, 0),
                               "DATABASE", dbname, NULL, NULL,
                               outbuf);
 
    PQclear(res);
 
    /* Now look for role-and-database-specific options */
    printfPQExpBuffer(buf, "SELECT rolname, unnest(setconfig) "
                      "FROM pg_db_role_setting s, pg_roles r "
                      "WHERE setrole = r.oid AND setdatabase = '%u'::oid",
                      dboid);
 
    res = ExecuteSqlQuery(AH, buf->data, PGRES_TUPLES_OK);
 
    for (int i = 0; i < PQntuples(res); i++)
        makeAlterConfigCommand(conn, PQgetvalue(res, i, 1),
                               "ROLE", PQgetvalue(res, i, 0),
                               "DATABASE", dbname,
                               outbuf);
 
    PQclear(res);
 
    destroyPQExpBuffer(buf);
}

References buf, conn, createPQExpBuffer(), dbname, destroyPQExpBuffer(), ExecuteSqlQuery(), GetConnection(), i, makeAlterConfigCommand(), PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), printfPQExpBuffer(), and res.

Referenced by dumpDatabase().

dumpDefaultACL()

static void dumpDefaultACL ( Archive *  fout, const DefaultACLInfo *  daclinfo  )

static

Definition at line 14832 of file pg_dump.c.

{
    DumpOptions *dopt = fout->dopt;
    PQExpBuffer q;
    PQExpBuffer tag;
    const char *type;
 
    /* Do nothing in data-only dump, or if we're skipping ACLs */
    if (dopt->dataOnly || dopt->aclsSkip)
        return;
 
    q = createPQExpBuffer();
    tag = createPQExpBuffer();
 
    switch (daclinfo->defaclobjtype)
    {
        case DEFACLOBJ_RELATION:
            type = "TABLES";
            break;
        case DEFACLOBJ_SEQUENCE:
            type = "SEQUENCES";
            break;
        case DEFACLOBJ_FUNCTION:
            type = "FUNCTIONS";
            break;
        case DEFACLOBJ_TYPE:
            type = "TYPES";
            break;
        case DEFACLOBJ_NAMESPACE:
            type = "SCHEMAS";
            break;
        default:
            /* shouldn't get here */
            pg_fatal("unrecognized object type in default privileges: %d",
                     (int) daclinfo->defaclobjtype);
            type = "";          /* keep compiler quiet */
    }
 
    appendPQExpBuffer(tag, "DEFAULT PRIVILEGES FOR %s", type);
 
    /* build the actual command(s) for this tuple */
    if (!buildDefaultACLCommands(type,
                                 daclinfo->dobj.namespace != NULL ?
                                 daclinfo->dobj.namespace->dobj.name : NULL,
                                 daclinfo->dacl.acl,
                                 daclinfo->dacl.acldefault,
                                 daclinfo->defaclrole,
                                 fout->remoteVersion,
                                 q))
        pg_fatal("could not parse default ACL list (%s)",
                 daclinfo->dacl.acl);
 
    if (daclinfo->dobj.dump & DUMP_COMPONENT_ACL)
        ArchiveEntry(fout, daclinfo->dobj.catId, daclinfo->dobj.dumpId,
                     ARCHIVE_OPTS(.tag = tag->data,
                                  .namespace = daclinfo->dobj.namespace ?
                                  daclinfo->dobj.namespace->dobj.name : NULL,
                                  .owner = daclinfo->defaclrole,
                                  .description = "DEFAULT ACL",
                                  .section = SECTION_POST_DATA,
                                  .createStmt = q->data));
 
    destroyPQExpBuffer(tag);
    destroyPQExpBuffer(q);
}